From 837cbebf5a46c7e3fabc69d1db6eaa9b56303702 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 18 May 2023 16:35:37 +0200 Subject: [PATCH 01/42] WIP: MSR method for Banzhaf --- src/pydvl/value/sampler.py | 13 ++++++ src/pydvl/value/semivalues.py | 79 ++++++++++++++++++++++++++++++++++ src/pydvl/value/stopping.py | 33 ++++++++++++++ tests/value/test_semivalues.py | 8 ++++ 4 files changed, 133 insertions(+) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 08cabe372..96fcb7b85 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -312,6 +312,19 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 +class MSRSampler(PowersetSampler[T]): + def __iter__(self) -> Iterator[SampleType]: + if len(self) == 0: + return + while True: + subset = random_subset(self.indices) + yield -1, subset + self._n_samples += 1 + + def weight(self, subset: NDArray[T]) -> float: + return float(2 ** (self._n - 1)) if self._n > 0 else 1.0 + + class AntitheticSampler(StochasticSamplerMixin, PowersetSampler[IndexT]): """An iterator to perform uniform random sampling of subsets, and their complements. diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 2119e38a9..fa05b94ca 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -104,6 +104,7 @@ from pydvl.utils.types import IndexT, Seed from pydvl.value import ValuationResult from pydvl.value.sampler import ( + MSRSampler, PermutationSampler, PowersetSampler, SampleT, @@ -140,6 +141,84 @@ def __call__(self, n: int, k: int) -> float: ... +def _msr_banzhaf( + sampler: MSRSampler, + u: Utility, + done: StoppingCriterion, + *, + job_id: int = 1, + progress: bool = False, +) -> ValuationResult: + """Inner loop of the MSR-Banzhaf approximation. + + See :func:`msr_banzhaf` for details. + + :param sampler: The subset sampler to use for utility computations. + :param u: Utility object with model, data, and scoring function. + :param done: Stopping criterion. + :param progress: Whether to display progress bars for each job. + :param job_id: id to use for reporting progress. + :return: Object with the results. + """ + + if not isinstance(sampler, MSRSampler): + raise TypeError("MSR-Banzhaf requires a MSRSampler.") + + result = ValuationResult.zeros( + algorithm=f"msr-banzhaf", + indices=sampler.indices, + data_names=[u.data.data_names[i] for i in sampler.indices], + ) + + samples = takewhile(lambda _: not done(result), sampler) + pbar = tqdm(disable=not progress, position=job_id, total=100, unit="%") + for _, s in samples: + pbar.n = 100 * done.completion() + pbar.refresh() + _u = u(s) + for idx in sampler.indices: + # FIXME: this is the wrong normalization + + marginal = _u * (1 if idx in s else -1) + result.update(idx, marginal) + + return result + + +def msr_banzhaf( + u: Utility, + done: StoppingCriterion, + *, + n_jobs: int = 1, + config: ParallelConfig = ParallelConfig(), + progress: bool = False, +) -> ValuationResult: + r"""Maximum-Sample-Reuse Monte Carlo approximation to Banzhaf index. + + Following :footcite:t:`wang_data_2022`, the MSR-Banzhaf Monte Carlo + approximation uses each sample $S$ of the whole dataset $D$ for each index. + This is made possible by the formulation: + + TODO... + + :param u: Utility object with model, data, and scoring function. + :param done: Stopping criterion. + :param n_jobs: Number of parallel jobs to run. + :param config: Configuration for parallel jobs. + :param progress: Whether to display progress bars for each job. + :return: Object with the results. + """ + map_reduce_job: MapReduceJob[PowersetSampler, ValuationResult] = MapReduceJob( + MSRSampler(u.data.indices), + map_func=_msr_banzhaf, + reduce_func=lambda results: reduce(operator.add, results), + map_kwargs=dict(u=u, done=done, progress=progress), + config=config, + n_jobs=n_jobs, + ) + return map_reduce_job() + + MarginalT = Tuple[IndexT, float] diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 206cf630c..8efed00da 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -126,6 +126,7 @@ import numpy as np from numpy.typing import NDArray +from scipy.stats import spearmanr from pydvl.utils import Status from pydvl.value import ValuationResult @@ -626,3 +627,35 @@ def reset(self): def __str__(self): return f"HistoryDeviation(n_steps={self.n_steps}, rtol={self.rtol})" + + +class RankStability(StoppingCriterion): + r"""A check for stability of Spearman correlation between checks. + + When the change in rank correlation between two successive iterations is + below a given threshold, the computation is terminated. + + This criterion is used in :footcite:t:`wang_data_2022`. + """ + + def __init__(self, rtol: float, modify_result: bool = True): + super().__init__(modify_result=modify_result) + if rtol <= 0 or rtol >= 1: + raise ValueError("rtol must be in (0, 1)") + self.rtol = rtol + self._memory = None # type: ignore + self._corr = 0.0 + + def _check(self, r: ValuationResult) -> Status: + if self._memory is None: + self._memory = r.values.copy() + self._converged = np.full(len(r), False) + return Status.Pending + + corr = spearmanr(self._memory, r.values)[0] + self._memory = r.values.copy() + if np.isclose(corr, self._corr, rtol=self.rtol): + self._converged = np.full(len(r), True) + return Status.Converged + self._corr = corr + return Status.Pending diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index e33f92543..e12ea4bcc 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -22,6 +22,7 @@ banzhaf_coefficient, beta_coefficient, compute_generic_semivalues, + msr_banzhaf, shapley_coefficient, ) from pydvl.value.stopping import HistoryDeviation, MaxUpdates @@ -61,6 +62,13 @@ def test_marginal_batch_size(test_game, sampler, coefficient, batch_size, seed): assert set(marginals_single) == set(marginals_batch) +@pytest.mark.parametrize("num_samples", [5]) +def test_msr_banzhaf(num_samples: int, analytic_banzhaf): + u, exact_values = analytic_banzhaf + values = msr_banzhaf(u, AbsoluteStandardError(0.02, 1.0) | MaxUpdates(300)) + check_values(values, exact_values, rtol=0.15) + + @pytest.mark.parametrize("n", [10, 100]) @pytest.mark.parametrize( "coefficient", From 800a36a496a310b54d3a016023f5f64beb4b5294 Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Tue, 19 Mar 2024 11:32:21 +0100 Subject: [PATCH 02/42] wip: adapt to new structure of semivalue computation --- src/pydvl/value/sampler.py | 16 +++-- src/pydvl/value/semivalues.py | 130 +++++++++++++--------------------- src/pydvl/value/stopping.py | 20 ++++++ 3 files changed, 82 insertions(+), 84 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 96fcb7b85..9b77e2f86 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -312,17 +312,23 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 -class MSRSampler(PowersetSampler[T]): - def __iter__(self) -> Iterator[SampleType]: +class MSRSampler(StochasticSamplerMixin, PowersetSampler[IndexT]): + """An iterator to perform MSR Monte Carlo sampling of subsets. + + This sampler creates random subsets of the data. + This sampler is used in :footcite:t:`wang_data_2022`. + """ + def __iter__(self) -> Iterator[SampleT]: if len(self) == 0: return while True: - subset = random_subset(self.indices) + subset = random_subset(self.indices, seed=self._rng) yield -1, subset self._n_samples += 1 - def weight(self, subset: NDArray[T]) -> float: - return float(2 ** (self._n - 1)) if self._n > 0 else 1.0 + @classmethod + def weight(cls, n: int, subset_len: int) -> float: + return float(2 ** (n - 1)) if n > 0 else 1.0 class AntitheticSampler(StochasticSamplerMixin, PowersetSampler[IndexT]): diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index fa05b94ca..a992b27fc 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -110,7 +110,7 @@ SampleT, StochasticSampler, ) -from pydvl.value.stopping import MaxUpdates, StoppingCriterion +from pydvl.value.stopping import MaxUpdates, StoppingCriterion, RankStability __all__ = [ "compute_banzhaf_semivalues", @@ -141,84 +141,6 @@ def __call__(self, n: int, k: int) -> float: ... -def _msr_banzhaf( - sampler: MSRSampler, - u: Utility, - done: StoppingCriterion, - *, - job_id: int = 1, - progress: bool = False, -) -> ValuationResult: - """Inner loop of the MSR-Banzhaf approximation. - - See :func:`msr_banzhaf` for details. - - :param sampler: The subset sampler to use for utility computations. - :param u: Utility object with model, data, and scoring function. - :param done: Stopping criterion. - :param progress: Whether to display progress bars for each job. - :param job_id: id to use for reporting progress. - :return: Object with the results. - """ - - if not isinstance(sampler, MSRSampler): - raise TypeError("MSR-Banzhaf requires a MSRSampler.") - - result = ValuationResult.zeros( - algorithm=f"msr-banzhaf", - indices=sampler.indices, - data_names=[u.data.data_names[i] for i in sampler.indices], - ) - - samples = takewhile(lambda _: not done(result), sampler) - pbar = tqdm(disable=not progress, position=job_id, total=100, unit="%") - for _, s in samples: - pbar.n = 100 * done.completion() - pbar.refresh() - _u = u(s) - for idx in sampler.indices: - # FIXME: this is the wrong normalization - - marginal = _u * (1 if idx in s else -1) - result.update(idx, marginal) - - return result - - -def msr_banzhaf( - u: Utility, - done: StoppingCriterion, - *, - n_jobs: int = 1, - config: ParallelConfig = ParallelConfig(), - progress: bool = False, -) -> ValuationResult: - r"""Maximum-Sample-Reuse Monte Carlo approximation to Banzhaf index. - - Following :footcite:t:`wang_data_2022`, the MSR-Banzhaf Monte Carlo - approximation uses each sample $S$ of the whole dataset $D$ for each index. - This is made possible by the formulation: - - TODO... - - :param u: Utility object with model, data, and scoring function. - :param done: Stopping criterion. - :param n_jobs: Number of parallel jobs to run. - :param config: Configuration for parallel jobs. - :param progress: Whether to display progress bars for each job. - :return: Object with the results. - """ - map_reduce_job: MapReduceJob[PowersetSampler, ValuationResult] = MapReduceJob( - MSRSampler(u.data.indices), - map_func=_msr_banzhaf, - reduce_func=lambda results: reduce(operator.add, results), - map_kwargs=dict(u=u, done=done, progress=progress), - config=config, - n_jobs=n_jobs, - ) - return map_reduce_job() - - MarginalT = Tuple[IndexT, float] @@ -503,6 +425,56 @@ def compute_banzhaf_semivalues( ) +def compute_msr_banzhaf_semivalues( + u: Utility, + *, + done: StoppingCriterion = RankStability(0.01), + sampler_t: Type[StochasticSampler] = MSRSampler, + batch_size: int = 1, + n_jobs: int = 1, + config: ParallelConfig = ParallelConfig(), + progress: bool = False, + seed: Optional[Seed] = None, +) -> ValuationResult: + """Computes MSR sampled Banzhaf values for a given utility function. + + This is a convenience wrapper for + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues] + with the Banzhaf coefficient and MSR sampling. + + Args: + u: Utility object with model, data, and scoring function. + done: Stopping criterion. + sampler_t: The sampler type to use. See the + [sampler][pydvl.value.sampler] module for a list. + batch_size: Number of marginal evaluations per single parallel job. + n_jobs: Number of parallel jobs to use. + seed: Either an instance of a numpy random number generator or a seed + for it. + config: Object configuring parallel computation, with cluster address, + number of cpus, etc. + progress: Whether to display a progress bar. + + Returns: + Object with the results. + + !!! warning "Deprecation notice" + Parameter `batch_size` is for experimental use and will be removed in + future versions. + """ + # HACK: cannot infer return type because of useless IndexT, NameT + return compute_generic_semivalues( # type: ignore + sampler_t(u.data.indices, seed=seed), + u, + banzhaf_coefficient, + done, + batch_size=batch_size, + n_jobs=n_jobs, + config=config, + progress=progress, + ) + + def compute_beta_shapley_semivalues( u: Utility, *, diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 8efed00da..5f3e53225 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -140,6 +140,7 @@ "MinUpdates", "MaxTime", "HistoryDeviation", + "RankStability" ] logger = logging.getLogger(__name__) @@ -634,8 +635,15 @@ class RankStability(StoppingCriterion): When the change in rank correlation between two successive iterations is below a given threshold, the computation is terminated. + The criterion computes the Spearman correlation between two successive iterations. + The Spearman correlation uses the ordering indices of the given values and correlates them. + This means it focuses on the order of the elements instead of their exact values. + If the order stops changing (meaning the Banzhaf semivalues estimates converge), the criterion stops the algorithm. This criterion is used in :footcite:t:`wang_data_2022`. + + Args: + rtol: Relative tolerance for convergence ($\epsilon$ in the formula) """ def __init__(self, rtol: float, modify_result: bool = True): @@ -645,6 +653,7 @@ def __init__(self, rtol: float, modify_result: bool = True): self.rtol = rtol self._memory = None # type: ignore self._corr = 0.0 + self._completion = 0.0 def _check(self, r: ValuationResult) -> Status: if self._memory is None: @@ -654,8 +663,19 @@ def _check(self, r: ValuationResult) -> Status: corr = spearmanr(self._memory, r.values)[0] self._memory = r.values.copy() + self._completion = min(self.rtol / np.abs(corr-self._corr), 1.0) if np.isclose(corr, self._corr, rtol=self.rtol): self._converged = np.full(len(r), True) return Status.Converged self._corr = corr return Status.Pending + + def completion(self) -> float: + return self._completion + + def reset(self): + self._memory = None # type: ignore + self._corr = 0.0 + + def __str__(self): + return f"RankStability(rtol={self.rtol})" From f5796448f083156bdd6daa6c4b614a0869eb4a66 Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Tue, 19 Mar 2024 11:33:11 +0100 Subject: [PATCH 03/42] linting --- src/pydvl/value/sampler.py | 1 + src/pydvl/value/semivalues.py | 2 +- src/pydvl/value/stopping.py | 4 ++-- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 9b77e2f86..dd884bf73 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -318,6 +318,7 @@ class MSRSampler(StochasticSamplerMixin, PowersetSampler[IndexT]): This sampler creates random subsets of the data. This sampler is used in :footcite:t:`wang_data_2022`. """ + def __iter__(self) -> Iterator[SampleT]: if len(self) == 0: return diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index a992b27fc..37fbc32bd 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -110,7 +110,7 @@ SampleT, StochasticSampler, ) -from pydvl.value.stopping import MaxUpdates, StoppingCriterion, RankStability +from pydvl.value.stopping import MaxUpdates, RankStability, StoppingCriterion __all__ = [ "compute_banzhaf_semivalues", diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 5f3e53225..9a500d2c9 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -140,7 +140,7 @@ "MinUpdates", "MaxTime", "HistoryDeviation", - "RankStability" + "RankStability", ] logger = logging.getLogger(__name__) @@ -663,7 +663,7 @@ def _check(self, r: ValuationResult) -> Status: corr = spearmanr(self._memory, r.values)[0] self._memory = r.values.copy() - self._completion = min(self.rtol / np.abs(corr-self._corr), 1.0) + self._completion = min(self.rtol / np.abs(corr - self._corr), 1.0) if np.isclose(corr, self._corr, rtol=self.rtol): self._converged = np.full(len(r), True) return Status.Converged From 699e9cb0d20def9c42b394e7a7dc0ad05c4b4dd9 Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Thu, 21 Mar 2024 15:53:55 +0100 Subject: [PATCH 04/42] wip: refactor to future processor --- notebooks/msr_banzhaf_spotify.ipynb | 988 ++++++++++++++++++++++++++++ src/pydvl/value/sampler.py | 3 +- src/pydvl/value/semivalues.py | 154 ++++- src/pydvl/value/stopping.py | 15 +- tests/value/test_semivalues.py | 23 +- 5 files changed, 1151 insertions(+), 32 deletions(-) create mode 100644 notebooks/msr_banzhaf_spotify.ipynb diff --git a/notebooks/msr_banzhaf_spotify.ipynb b/notebooks/msr_banzhaf_spotify.ipynb new file mode 100644 index 000000000..fd98269d9 --- /dev/null +++ b/notebooks/msr_banzhaf_spotify.ipynb @@ -0,0 +1,988 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Maximum Sample Reuse Banzhaf Values for data valuation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook shows how to compute Banzhaf values using pyDVL.\n", + "\n", + "In order to illustrate the practical advantages, we will predict the popularity of songs in the dataset [Top Hits Spotify from 2000-2019](https://www.kaggle.com/datasets/paradisejoy/top-hits-spotify-from-20002019), and highlight how data valuation can help investigate and boost the performance of the models. In doing so, we will describe the basic usage patterns of pyDVL.\n", + "\n", + "Recall that data value is a function of three things:\n", + "\n", + "1. The dataset.\n", + "2. The model.\n", + "3. The performance metric or scoring function.\n", + "\n", + "Below we will describe how to instantiate each one of these objects and how to use them for data valuation. Please also see the [documentation on data valuation](../../value/)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "We begin by importing the main libraries and setting some defaults.\n", + "\n", + "
\n", + "\n", + "If you are reading this in the documentation, some boilerplate (including most plotting code) has been omitted for convenience.\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "%load_ext autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "%autoreload\n", + "%matplotlib inline\n", + "\n", + "import os\n", + "import random\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.ensemble import GradientBoostingRegressor\n", + "from sklearn.metrics import mean_absolute_error\n", + "\n", + "plt.ioff() # Prevent jupyter from automatically plotting\n", + "plt.rcParams[\"figure.figsize\"] = (20, 6)\n", + "plt.rcParams[\"font.size\"] = 12\n", + "plt.rcParams[\"xtick.labelsize\"] = 12\n", + "plt.rcParams[\"ytick.labelsize\"] = 10\n", + "plt.rcParams[\"axes.facecolor\"] = (1, 1, 1, 0)\n", + "plt.rcParams[\"figure.facecolor\"] = (1, 1, 1, 0)\n", + "\n", + "is_CI = os.environ.get(\"CI\")\n", + "random_state = 24\n", + "random.seed(random_state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will be using the following functions from pyDVL. The main entry point is the function [compute_shapley_values()](../../api/pydvl/value/shapley/common/#pydvl.value.shapley.common.compute_shapley_values), which provides a facade to all Shapley methods. In order to use it we need the classes [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset), [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility) and [Scorer](../../api/pydvl/utils/score/#pydvl.utils.score.Scorer)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "%autoreload\n", + "from pydvl.reporting.plots import plot_shapley\n", + "from pydvl.utils.dataset import GroupedDataset\n", + "from support.shapley import load_spotify_dataset\n", + "from pydvl.value import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading and grouping the dataset\n", + "\n", + "pyDVL provides a support function for this notebook, `load_spotify_dataset()`, which downloads data on songs published after 2014, and splits 30% of data for testing, and 30% of the remaining data for validation. The return value is a triple of training, validation and test data as lists of the form `[X_input, Y_label]`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "training_data, val_data, test_data = load_spotify_dataset(\n", + " val_size=0.3, test_size=0.3, target_column=\"popularity\", random_state=random_state\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "# In CI we only use a subset of the training set\n", + "if is_CI:\n", + " ci_test_artists = [\"Billie Eilish\", \"DJ Snake\", \"Eminem\", \"Adele\", \"Maroon 5\"]\n", + " training_data[0] = training_data[0][\n", + " training_data[0][\"artist\"].isin(ci_test_artists)\n", + " ]\n", + " training_data[1] = training_data[1][training_data[0].index]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
artistsongduration_msexplicityeardanceabilityenergykeyloudnessmodespeechinessacousticnessinstrumentalnesslivenessvalencetempogenre
1561Fetty Wap679 (feat. Remy Boyz)196693True20150.6180.7177-5.73810.31800.002560.0000000.62500.603190.0508
1410Meghan TrainorAll About That Bass187920True20150.8070.8879-3.72610.05030.057300.0000030.12400.961134.05214
1772Katy PerryChained To The Rhythm237733False20170.5620.8000-5.40410.11200.081400.0000000.19900.47195.02914
1670SigalaSweet Lovin' - Radio Edit202149False20150.6830.91010-1.23110.05150.055300.0000050.33600.674124.97715
1780Liam PayneStrip That Down204502False20170.8690.4856-5.59510.05450.246000.0000000.07650.527106.02814
\n", + "
" + ], + "text/plain": [ + " artist song duration_ms explicit year \\\n", + "1561 Fetty Wap 679 (feat. Remy Boyz) 196693 True 2015 \n", + "1410 Meghan Trainor All About That Bass 187920 True 2015 \n", + "1772 Katy Perry Chained To The Rhythm 237733 False 2017 \n", + "1670 Sigala Sweet Lovin' - Radio Edit 202149 False 2015 \n", + "1780 Liam Payne Strip That Down 204502 False 2017 \n", + "\n", + " danceability energy key loudness mode speechiness acousticness \\\n", + "1561 0.618 0.717 7 -5.738 1 0.3180 0.00256 \n", + "1410 0.807 0.887 9 -3.726 1 0.0503 0.05730 \n", + "1772 0.562 0.800 0 -5.404 1 0.1120 0.08140 \n", + "1670 0.683 0.910 10 -1.231 1 0.0515 0.05530 \n", + "1780 0.869 0.485 6 -5.595 1 0.0545 0.24600 \n", + "\n", + " instrumentalness liveness valence tempo genre \n", + "1561 0.000000 0.6250 0.603 190.050 8 \n", + "1410 0.000003 0.1240 0.961 134.052 14 \n", + "1772 0.000000 0.1990 0.471 95.029 14 \n", + "1670 0.000005 0.3360 0.674 124.977 15 \n", + "1780 0.000000 0.0765 0.527 106.028 14 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "training_data[0].head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The dataset has many high-level features, some quite intuitive ('duration_ms' or 'tempo'), while others are a bit more cryptic ('valence'?). For information on each feature, please consult [the dataset's website](https://www.kaggle.com/datasets/paradisejoy/top-hits-spotify-from-20002019).\n", + "\n", + "In our analysis, we will use all the columns, except for 'artist' and 'song', to predict the 'popularity' of each song. We will nonetheless keep the information on song and artist in a separate object for future reference." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "song_name = training_data[0][\"song\"]\n", + "artist = training_data[0][\"artist\"]\n", + "training_data[0] = training_data[0].drop([\"song\", \"artist\"], axis=1)\n", + "test_data[0] = test_data[0].drop([\"song\", \"artist\"], axis=1)\n", + "val_data[0] = val_data[0].drop([\"song\", \"artist\"], axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Input and label data are then used to instantiate a [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset) object:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = Dataset(*training_data, *val_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The calculation of exact Banzhaf semivalues is computationally very expensive (exponentially so!) because it requires training the model on every possible subset of the training set. For this reason, PyDVL implements techniques to speed up the calculation, such as [Monte Carlo approximations](../../api/pydvl/value/shapley/montecarlo/), [surrogate models](../../api/pydvl/utils/utility/#pydvl.utils.utility.DataUtilityLearning) or [caching](../../api/pydvl/utils/caching/) of intermediate results and grouping of data to calculate group Shapley values instead of single data points.\n", + "\n", + "In our case, we will group songs by artist and calculate the Shapley value for the artists. Given the [pandas Series](https://pandas.pydata.org/docs/reference/api/pandas.Series.html) for 'artist', to group the dataset by it, one does the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "grouped_dataset = GroupedDataset.from_dataset(dataset=dataset, data_groups=artist)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating the utility and computing Banzhaf semivalues\n", + "\n", + "Now we can calculate the contribution of each group to the model performance.\n", + "\n", + "As a model, we use scikit-learn's [GradientBoostingRegressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html), but pyDVL can work with any model from sklearn, xgboost or lightgbm. More precisely, any model that implements the protocol [pydvl.utils.types.SupervisedModel](../../api/pydvl/utils/types/#pydvl.utils.types.SupervisedModel), which is just the standard sklearn interface of `fit()`,`predict()` and `score()` can be used to construct the utility.\n", + "\n", + "The third and final component is the scoring function. It can be anything like accuracy or $R^2$, and is set with a string from the [standard sklearn scoring methods](https://scikit-learn.org/stable/modules/model_evaluation.html). Please refer to that documentation on information on how to define your own scoring function.\n", + "\n", + "We group dataset, model and scoring function into an instance of [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Compute regular Banzhaf semivalue\n", + "utility = Utility(\n", + " model=GradientBoostingRegressor(n_estimators=3),\n", + " data=grouped_dataset,\n", + " scorer=Scorer(\"neg_mean_absolute_error\", default=0.0),\n", + ")\n", + "values = compute_banzhaf_semivalues(\n", + " utility,\n", + " # Stop if the standard error is below 1% of the range of the values (which is ~2),\n", + " # or if the number of updates exceeds 1000\n", + " done=AbsoluteStandardError(threshold=0.2, fraction=0.9) | MaxUpdates(1000),\n", + " n_jobs=-1,\n", + ")\n", + "values.sort(key=\"value\")\n", + "df = values.to_dataframe(column=\"data_value\", use_names=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's take a look at the returned dataframe:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
data_valuedata_value_stderr
DB Boulevard-0.8370060.001385
5 Seconds of Summer-0.7718060.185630
BLACKPINK-0.6569810.103397
Flume-0.6481980.160226
Adele-0.6284940.214410
\n", + "
" + ], + "text/plain": [ + " data_value data_value_stderr\n", + "DB Boulevard -0.837006 0.001385\n", + "5 Seconds of Summer -0.771806 0.185630\n", + "BLACKPINK -0.656981 0.103397\n", + "Flume -0.648198 0.160226\n", + "Adele -0.628494 0.214410" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us plot the results. In the next cell we will take the 30 artists with the lowest score and plot their values with 95% Normal confidence intervals. Keep in mind that Monte Carlo Banzhaf is typically very noisy, and it can take many steps to arrive at a clean estimate." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input", + "invertible-output" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "low_dvl = df.iloc[:30]\n", + "plot_shapley(\n", + " low_dvl,\n", + " level=0.05,\n", + " title=\"Artists with low values\",\n", + " xlabel=\"Artist\",\n", + " ylabel=\"Banzhaf value\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can immediately see that many artists (groups of samples) have very low, even negative value, which means that they tend to decrease the total score of the model when present in the training set! What happens if we remove them?\n", + "\n", + "In the next cell we create a new training set excluding the artists with the lowest scores:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "low_dvl_artists = df.iloc[: int(0.2 * len(df))].index.to_list()\n", + "artist_filter = ~artist.isin(low_dvl_artists)\n", + "X_train_good_dvl = training_data[0][artist_filter]\n", + "y_train_good_dvl = training_data[1][artist_filter]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will use this \"cleaned\" dataset to retrain the same model and compare its mean absolute error to the one trained on the full dataset. Notice that the score now is calculated using the test set, while in the calculation of the Shapley values we were using the validation set." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Improvement: 13.389073%\n" + ] + } + ], + "source": [ + "model_good_data = GradientBoostingRegressor(n_estimators=3).fit(\n", + " X_train_good_dvl, y_train_good_dvl\n", + ")\n", + "error_good_data = mean_absolute_error(\n", + " model_good_data.predict(test_data[0]), test_data[1]\n", + ")\n", + "\n", + "model_all_data = GradientBoostingRegressor(n_estimators=3).fit(\n", + " training_data[0], training_data[1]\n", + ")\n", + "error_all_data = mean_absolute_error(model_all_data.predict(test_data[0]), test_data[1])\n", + "\n", + "print(f\"Improvement: {100*(error_all_data - error_good_data)/error_all_data:02f}%\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The score has improved by almost 14%! This is quite an important result, as it shows a consistent process to improve the performance of a model by excluding data points from its training set." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\n", + "One must however proceed with caution instead of simply throwing away data. For one, `mean_absolute_error` is an estimate of generalization error on unseen data, so the improvement we see on the test set might not be as large upon deployment. It would be advisable to cross-validate this whole process to obtain more conservative estimates. It is also advisable to manually inspect the artists with low value and to try to understand the reason why the model behaves like it does. Finally, remember that **the value depends on the model chosen**! Artists that are detrimental to the Gradient Boosting Regressor might be informative for a different model (although it is likely that the worst ones share some characteristic making them \"bad\" for other regressors).\n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluation on anomalous data\n", + "\n", + "One interesting test is to corrupt some data and to monitor how their value changes. To do this, we will take one of the artists with the highest value and set the popularity of all their songs to 0." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input", + "invertible-output" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "high_dvl = df.iloc[-30:]\n", + "ax = plot_shapley(\n", + " high_dvl,\n", + " title=\"Artists with high values\",\n", + " xlabel=\"Artist\",\n", + " ylabel=\"Banzhaf value\",\n", + ")\n", + "ax.get_xticklabels()[high_dvl.index.get_loc(\"Billie Eilish\")].set_color(\"red\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us take all the songs by Billie Eilish, set their score to 0 and re-calculate the Banzhaf values." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "y_train_anomalous = training_data[1].copy(deep=True)\n", + "y_train_anomalous[artist == \"Billie Eilish\"] = 0\n", + "anomalous_dataset = Dataset(\n", + " x_train=training_data[0],\n", + " y_train=y_train_anomalous,\n", + " x_test=val_data[0],\n", + " y_test=val_data[1],\n", + ")\n", + "grouped_anomalous_dataset = GroupedDataset.from_dataset(anomalous_dataset, artist)\n", + "anomalous_utility = Utility(\n", + " model=GradientBoostingRegressor(n_estimators=3),\n", + " data=grouped_anomalous_dataset,\n", + " scorer=Scorer(\"neg_mean_absolute_error\", default=0.0),\n", + ")\n", + "values = compute_banzhaf_semivalues(\n", + " anomalous_utility,\n", + " done=AbsoluteStandardError(threshold=0.2, fraction=0.9) | MaxUpdates(1000),\n", + " n_jobs=-1,\n", + ")\n", + "values.sort(key=\"value\")\n", + "df = values.to_dataframe(column=\"data_value\", use_names=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us now consider the low-value artists (at least for predictive purposes, no claims are made about their artistic value!) and plot the results" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input", + "invertible-output" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "low_dvl = df.iloc[:30]\n", + "ax = plot_shapley(\n", + " low_dvl,\n", + " title=\"Artists with low data valuation scores\",\n", + " xlabel=\"Artist\",\n", + " ylabel=\"Shapley Value\",\n", + ")\n", + "ax.get_xticklabels()[low_dvl.index.get_loc(\"Billie Eilish\")].set_color(\"red\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And Billie Eilish (our anomalous data group) has moved from top contributor to having negative impact on the performance of the model, as expected!\n", + "\n", + "What is going on? A popularity of 0 for Billie Eilish's songs is inconsistent with listening patterns for other artists. In artificially setting this, we degrade the predictive power of the model.\n", + "\n", + "By dropping low-value groups or samples, one can often increase model performance, but by *inspecting* them, it is possible to identify bogus data sources or acquisition methods.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Maximum Sample Reuse Banzhaf\n", + "\n", + "Now, we want to use a method called Maximum Sample Reuse (MSR) which reuses samples for updating the Banzhaf values. The method is introduced by Wang et al. in the paper *Data Banzhaf: A Robust Data Valuation Framework for Machine Learning*." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/100 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
data_valuedata_value_stderr
Imagine Dragons-2.070629e-3200.0
Lil Pump-2.070629e-3200.0
Tom Walker-1.156114e-3210.0
Anuel AA-1.057300e-3210.0
Doja Cat-9.634280e-3220.0
\n", + "" + ], + "text/plain": [ + " data_value data_value_stderr\n", + "Imagine Dragons -2.070629e-320 0.0\n", + "Lil Pump -2.070629e-320 0.0\n", + "Tom Walker -1.156114e-321 0.0\n", + "Anuel AA -1.057300e-321 0.0\n", + "Doja Cat -9.634280e-322 0.0" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "high_dvl = df.iloc[-30:]\n", + "ax = plot_shapley(\n", + " high_dvl,\n", + " title=\"Artists with high values\",\n", + " xlabel=\"Artist\",\n", + " ylabel=\"MSR Banzhaf value\",\n", + ")\n", + "plt.show()" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + }, + "vscode": { + "interpreter": { + "hash": "4e000971326892723e7f31ded70802f690c31c3620f59a0f99e594aaee3047ef" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index dd884bf73..a93e4a9d3 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -329,7 +329,7 @@ def __iter__(self) -> Iterator[SampleT]: @classmethod def weight(cls, n: int, subset_len: int) -> float: - return float(2 ** (n - 1)) if n > 0 else 1.0 + return 1.0 class AntitheticSampler(StochasticSamplerMixin, PowersetSampler[IndexT]): @@ -470,4 +470,5 @@ def weight(cls, n: int, subset_len: int) -> float: PermutationSampler[IndexT], AntitheticSampler[IndexT], RandomHierarchicalSampler[IndexT], + MSRSampler[IndexT], ] diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 37fbc32bd..660485a12 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -90,9 +90,10 @@ import logging import math import warnings +from abc import ABC, abstractmethod from enum import Enum from itertools import islice -from typing import Iterable, List, Optional, Protocol, Tuple, Type, cast +from typing import Any, Iterable, List, Optional, Protocol, Tuple, Type, cast import numpy as np import scipy as sp @@ -114,6 +115,7 @@ __all__ = [ "compute_banzhaf_semivalues", + "compute_msr_banzhaf_semivalues", "compute_beta_shapley_semivalues", "compute_shapley_semivalues", "beta_coefficient", @@ -144,28 +146,125 @@ def __call__(self, n: int, k: int) -> float: MarginalT = Tuple[IndexT, float] -def _marginal( - u: Utility, coefficient: SVCoefficient, samples: Iterable[SampleT] -) -> Tuple[MarginalT, ...]: - """Computation of marginal utility. This is a helper function for - [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues]. +class MarginalFunction(ABC): + @abstractmethod + def __call__( + self, u: Utility, coefficient: SVCoefficient, samples: Iterable[SampleT] + ) -> Tuple[MarginalT, ...]: + raise NotImplementedError - Args: - u: Utility object with model, data, and scoring function. - coefficient: The semivalue coefficient and sampler weight - samples: A collection of samples. Each sample is a tuple of index and subset of - indices to compute a marginal utility. - Returns: - A collection of marginals. Each marginal is a tuple with index and its marginal - utility. - """ - n = len(u.data) - marginals: List[MarginalT] = [] - for idx, s in samples: - marginal = (u({idx}.union(s)) - u(s)) * coefficient(n, len(s)) - marginals.append((idx, marginal)) - return tuple(marginals) +class DefaultMarginal(MarginalFunction): + def __call__( + self, u: Utility, coefficient: SVCoefficient, samples: Iterable[SampleT] + ) -> Tuple[MarginalT, ...]: + """Computation of marginal utility. This is a helper function for + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues]. + + Args: + u: Utility object with model, data, and scoring function. + coefficient: The semivalue coefficient and sampler weight + samples: A collection of samples. Each sample is a tuple of index and subset of + indices to compute a marginal utility. + + Returns: + A collection of marginals. Each marginal is a tuple with index and its marginal + utility. + """ + n = len(u.data) + marginals: List[MarginalT] = [] + for idx, s in samples: + marginal = (u({idx}.union(s)) - u(s)) * coefficient(n, len(s)) + marginals.append((idx, marginal)) + return tuple(marginals) + + +class RawUtility(MarginalFunction): + def __call__( + self, u: Utility, coefficient: SVCoefficient, samples: Iterable[SampleT] + ) -> Tuple[MarginalT, ...]: + """Computation of marginal utility. This is a helper function for + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues]. + + Args: + u: Utility object with model, data, and scoring function. + coefficient: The semivalue coefficient and sampler weight + samples: A collection of samples. Each sample is a tuple of index and subset of + indices to compute a marginal utility. + + Returns: + A collection of marginals. Each marginal is a tuple with index and its marginal + utility. + """ + marginals: List[MarginalT] = [] + for idx, s in samples: + marginals.append((s, u(s))) + return tuple(marginals) + + +class FutureProcessor: + def __call__(self, future_result: Any) -> Any: + return future_result + + +class MSRFutureProcessor(FutureProcessor): + def __init__(self, u: Utility): + self.n = len(u.data) + self.all_indices = u.data.indices.copy() + self.point_in_subset = np.zeros((self.n,)) + self.positive_sums = np.zeros((self.n,)) + self.negative_sums = np.zeros((self.n,)) + self.total_evaluations = 0 + + def compute_values(self) -> np.ndarray: + points_not_in_subset = self.total_evaluations - self.point_in_subset + feasibility_map = np.logical_and( + self.point_in_subset > 0, points_not_in_subset > 0 + ) + values: np.ndarray = ( + np.divide(1, self.point_in_subset, where=feasibility_map) + * self.positive_sums + + np.divide(1, points_not_in_subset, where=feasibility_map) + * self.negative_sums + ) + return values + + def __call__(self, future_result: Tuple[List[IndexT], float]) -> Tuple[MarginalT]: + """Computation of marginal utility using Maximum Sample Reuse. + + This processor requires the Marginal Function to be set to RawUtility. + Then, this processor computes marginals based on the utility value and the index set provided. + + The final formula that gives the Banzhaf semivalue using MSR is: + $$\hat{\phi}_{MSR}(i) = \frac{1}{|\mathbf{S}_{\ni i}|} \sum_{S \in \mathbf{S}_{\ni i}} U(S) + - \frac{1}{|\mathbf{S}_{\not{\ni} i}|} \sum_{S \in \mathbf{S}_{\not{\ni} i}} U(S)$$ + + Args: + future_result: Result of the parallel computing jobs comprised of + a list of indices that were used to evaluate the utility, and the evaluation result (metric). + + Returns: + A collection of marginals. Each marginal is a tuple with index and its marginal + utility. + """ + log.debug("MSR Future Processor called") + marginals: List[MarginalT] = [] + for s, evaluation in future_result: + previous_values = self.compute_values() + self.total_evaluations += 1 + self.point_in_subset[s] += 1 + self.positive_sums[s] += evaluation + not_s = np.setdiff1d(self.all_indices, s) + self.negative_sums[not_s] += evaluation + new_values = self.compute_values() + # Hack to work around the update mechanic that does not work out of the box for MSR + marginal_vals = ( + self.total_evaluations * new_values + - (self.total_evaluations - 1) * previous_values + ) + for data_index in range(self.n): + marginals.append((data_index, float(marginal_vals[data_index]))) + return tuple(marginals) # @deprecated( @@ -179,6 +278,8 @@ def compute_generic_semivalues( coefficient: SVCoefficient, done: StoppingCriterion, *, + marginal: MarginalFunction = DefaultMarginal(), + future_processor: FutureProcessor = FutureProcessor(), batch_size: int = 1, skip_converged: bool = False, n_jobs: int = 1, @@ -259,8 +360,9 @@ def compute_generic_semivalues( completed, pending = wait(pending, timeout=1, return_when=FIRST_COMPLETED) for future in completed: - for idx, marginal in future.result(): - result.update(idx, marginal) + processed_future = future_processor(future.result()) + for idx, marginal_val in processed_future: + result.update(idx, marginal_val) if done(result): return result @@ -282,7 +384,7 @@ def compute_generic_semivalues( if filtered_samples: pending.add( executor.submit( - _marginal, + marginal, u=u, coefficient=correction, samples=filtered_samples, @@ -466,8 +568,10 @@ def compute_msr_banzhaf_semivalues( return compute_generic_semivalues( # type: ignore sampler_t(u.data.indices, seed=seed), u, - banzhaf_coefficient, + lambda n, k: 1.0, # Coefficients not needed done, + marginal=RawUtility(), + future_processor=MSRFutureProcessor(u), batch_size=batch_size, n_jobs=n_jobs, config=config, diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 9a500d2c9..ab80066d7 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -646,7 +646,9 @@ class RankStability(StoppingCriterion): rtol: Relative tolerance for convergence ($\epsilon$ in the formula) """ - def __init__(self, rtol: float, modify_result: bool = True): + def __init__( + self, rtol: float, modify_result: bool = True, min_iterations: int = 10 + ): super().__init__(modify_result=modify_result) if rtol <= 0 or rtol >= 1: raise ValueError("rtol must be in (0, 1)") @@ -654,8 +656,11 @@ def __init__(self, rtol: float, modify_result: bool = True): self._memory = None # type: ignore self._corr = 0.0 self._completion = 0.0 + self._iterations = 0 + self.min_iterations = min_iterations def _check(self, r: ValuationResult) -> Status: + self._iterations += 1 if self._memory is None: self._memory = r.values.copy() self._converged = np.full(len(r), False) @@ -664,8 +669,14 @@ def _check(self, r: ValuationResult) -> Status: corr = spearmanr(self._memory, r.values)[0] self._memory = r.values.copy() self._completion = min(self.rtol / np.abs(corr - self._corr), 1.0) - if np.isclose(corr, self._corr, rtol=self.rtol): + if ( + np.isclose(corr, self._corr, rtol=self.rtol) + and self._iterations > self.min_iterations + ): self._converged = np.full(len(r), True) + logger.debug( + f"RankStability has converged with {corr=} in iteration {self._iterations}" + ) return Status.Converged self._corr = corr return Status.Pending diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index e12ea4bcc..9d1e1dcce 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -17,6 +17,7 @@ UniformSampler, ) from pydvl.value.semivalues import ( + MSRMarginal, SVCoefficient, _marginal, banzhaf_coefficient, @@ -25,7 +26,7 @@ msr_banzhaf, shapley_coefficient, ) -from pydvl.value.stopping import HistoryDeviation, MaxUpdates +from pydvl.value.stopping import HistoryDeviation, MaxUpdates, RankStability from . import check_values from .utils import timed @@ -63,10 +64,24 @@ def test_marginal_batch_size(test_game, sampler, coefficient, batch_size, seed): @pytest.mark.parametrize("num_samples", [5]) -def test_msr_banzhaf(num_samples: int, analytic_banzhaf): +def test_msr_banzhaf( + num_samples: int, analytic_banzhaf, parallel_config, n_jobs, seed: Seed +): u, exact_values = analytic_banzhaf - values = msr_banzhaf(u, AbsoluteStandardError(0.02, 1.0) | MaxUpdates(300)) - check_values(values, exact_values, rtol=0.15) + sampler = MSRSampler() + marginal = MSRMarginal() + values = compute_generic_semivalues( + sampler(u.data.indices, seed=seed), + u=u, + coefficient=coefficient, + marginal=marginal, + criterion=RankStability(rtol=0.1) | MaxUpdates(100), + skip_converged=False, + n_jobs=n_jobs, + config=parallel_config, + progress=True, + ) + check_values(values, exact_values, rtol=0.1) @pytest.mark.parametrize("n", [10, 100]) From 1f913c8aab6b09c374f52a2009c990c5502e94ad Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Thu, 21 Mar 2024 15:54:40 +0100 Subject: [PATCH 05/42] linting --- src/pydvl/value/semivalues.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 660485a12..630847ab8 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -232,7 +232,7 @@ def compute_values(self) -> np.ndarray: def __call__(self, future_result: Tuple[List[IndexT], float]) -> Tuple[MarginalT]: """Computation of marginal utility using Maximum Sample Reuse. - This processor requires the Marginal Function to be set to RawUtility. + This processor requires the Marginal Function to be set to RawUtility. Then, this processor computes marginals based on the utility value and the index set provided. The final formula that gives the Banzhaf semivalue using MSR is: From f657b88ff09f4626c3dd2a5d9bcb925426fa24b5 Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Thu, 21 Mar 2024 16:07:29 +0100 Subject: [PATCH 06/42] fix type hints --- src/pydvl/value/semivalues.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 630847ab8..078c9af7a 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -229,7 +229,7 @@ def compute_values(self) -> np.ndarray: ) return values - def __call__(self, future_result: Tuple[List[IndexT], float]) -> Tuple[MarginalT]: + def __call__(self, future_result: List[Tuple[List[IndexT], float]]) -> Tuple[MarginalT, ...]: """Computation of marginal utility using Maximum Sample Reuse. This processor requires the Marginal Function to be set to RawUtility. From 3564ea6f6a5c18a862699519cd4163def4741fad Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Thu, 21 Mar 2024 16:07:47 +0100 Subject: [PATCH 07/42] fix type hints --- src/pydvl/value/semivalues.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 078c9af7a..eaf5adcf0 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -229,7 +229,9 @@ def compute_values(self) -> np.ndarray: ) return values - def __call__(self, future_result: List[Tuple[List[IndexT], float]]) -> Tuple[MarginalT, ...]: + def __call__( + self, future_result: List[Tuple[List[IndexT], float]] + ) -> Tuple[MarginalT, ...]: """Computation of marginal utility using Maximum Sample Reuse. This processor requires the Marginal Function to be set to RawUtility. From c97821abe70fc6f0addf43e79f74f54c81b7db82 Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Tue, 26 Mar 2024 18:22:14 +0100 Subject: [PATCH 08/42] fix some bugs to achieve correct banzhaf semivalues --- notebooks/msr_banzhaf_spotify.ipynb | 578 ++++++++++++++++++++++++---- src/pydvl/value/semivalues.py | 19 +- src/pydvl/value/stopping.py | 13 +- 3 files changed, 525 insertions(+), 85 deletions(-) diff --git a/notebooks/msr_banzhaf_spotify.ipynb b/notebooks/msr_banzhaf_spotify.ipynb index fd98269d9..4c5be9b4c 100644 --- a/notebooks/msr_banzhaf_spotify.ipynb +++ b/notebooks/msr_banzhaf_spotify.ipynb @@ -41,26 +41,43 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 22, "metadata": { "tags": [ "hide" ] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 23, "metadata": { "tags": [ "hide" ] }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:matplotlib.pyplot:Loaded backend module://matplotlib_inline.backend_inline version unknown.\n" + ] + } + ], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -94,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -116,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 25, "metadata": { "editable": true, "slideshow": { @@ -133,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 26, "metadata": { "editable": true, "slideshow": { @@ -156,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -330,6 +347,178 @@ "execution_count": 6, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
artistsongduration_msexplicityeardanceabilityenergykeyloudnessmodespeechinessacousticnessinstrumentalnesslivenessvalencetempogenre
1561Fetty Wap679 (feat. Remy Boyz)196693True20150.6180.7177-5.73810.31800.002560.0000000.62500.603190.0508
1410Meghan TrainorAll About That Bass187920True20150.8070.8879-3.72610.05030.057300.0000030.12400.961134.05214
1772Katy PerryChained To The Rhythm237733False20170.5620.8000-5.40410.11200.081400.0000000.19900.47195.02914
1670SigalaSweet Lovin' - Radio Edit202149False20150.6830.91010-1.23110.05150.055300.0000050.33600.674124.97715
1780Liam PayneStrip That Down204502False20170.8690.4856-5.59510.05450.246000.0000000.07650.527106.02814
\n", + "
" + ], + "text/plain": [ + " artist song duration_ms explicit year \\\n", + "1561 Fetty Wap 679 (feat. Remy Boyz) 196693 True 2015 \n", + "1410 Meghan Trainor All About That Bass 187920 True 2015 \n", + "1772 Katy Perry Chained To The Rhythm 237733 False 2017 \n", + "1670 Sigala Sweet Lovin' - Radio Edit 202149 False 2015 \n", + "1780 Liam Payne Strip That Down 204502 False 2017 \n", + "\n", + " danceability energy key loudness mode speechiness acousticness \\\n", + "1561 0.618 0.717 7 -5.738 1 0.3180 0.00256 \n", + "1410 0.807 0.887 9 -3.726 1 0.0503 0.05730 \n", + "1772 0.562 0.800 0 -5.404 1 0.1120 0.08140 \n", + "1670 0.683 0.910 10 -1.231 1 0.0515 0.05530 \n", + "1780 0.869 0.485 6 -5.595 1 0.0545 0.24600 \n", + "\n", + " instrumentalness liveness valence tempo genre \n", + "1561 0.000000 0.6250 0.603 190.050 8 \n", + "1410 0.000003 0.1240 0.961 134.052 14 \n", + "1772 0.000000 0.1990 0.471 95.029 14 \n", + "1670 0.000005 0.3360 0.674 124.977 15 \n", + "1780 0.000000 0.0765 0.527 106.028 14 " + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -347,7 +536,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -367,7 +556,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -385,7 +574,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -409,7 +598,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -418,6 +607,9 @@ "text": [ "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", + " warnings.warn(\n", + "WARNING:pydvl.value.semivalues:PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", " warnings.warn(\n" ] } @@ -449,7 +641,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -479,29 +671,29 @@ " \n", " \n", " \n", - " DB Boulevard\n", - " -0.837006\n", - " 0.001385\n", + " Kendrick Lamar\n", + " -0.885800\n", + " 0.179126\n", " \n", " \n", - " 5 Seconds of Summer\n", - " -0.771806\n", - " 0.185630\n", + " Alessia Cara\n", + " -0.752220\n", + " 0.090328\n", " \n", " \n", - " BLACKPINK\n", - " -0.656981\n", - " 0.103397\n", + " Ava Max\n", + " -0.728605\n", + " 0.141735\n", " \n", " \n", - " Flume\n", - " -0.648198\n", - " 0.160226\n", + " 5 Seconds of Summer\n", + " -0.502302\n", + " 0.032807\n", " \n", " \n", - " Adele\n", - " -0.628494\n", - " 0.214410\n", + " ZAYN\n", + " -0.426648\n", + " 0.137434\n", " \n", " \n", "\n", @@ -509,16 +701,84 @@ ], "text/plain": [ " data_value data_value_stderr\n", - "DB Boulevard -0.837006 0.001385\n", - "5 Seconds of Summer -0.771806 0.185630\n", - "BLACKPINK -0.656981 0.103397\n", - "Flume -0.648198 0.160226\n", - "Adele -0.628494 0.214410" + "Kendrick Lamar -0.885800 0.179126\n", + "Alessia Cara -0.752220 0.090328\n", + "Ava Max -0.728605 0.141735\n", + "5 Seconds of Summer -0.502302 0.032807\n", + "ZAYN -0.426648 0.137434" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
data_valuedata_value_stderr
Jonas Blue-0.7150330.047940
Major Lazer-0.6576950.111218
Years & Years-0.5468370.078450
Justin Bieber-0.5035730.054793
Liam Payne-0.4891800.117529
\n", + "
" + ], + "text/plain": [ + " data_value data_value_stderr\n", + "Jonas Blue -0.715033 0.047940\n", + "Major Lazer -0.657695 0.111218\n", + "Years & Years -0.546837 0.078450\n", + "Justin Bieber -0.503573 0.054793\n", + "Liam Payne -0.489180 0.117529" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -534,7 +794,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 33, "metadata": { "editable": true, "slideshow": { @@ -548,7 +808,19 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -582,7 +854,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -601,14 +873,15 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Improvement: 13.389073%\n" + "Improvement: 11.132172%\n", + "Improvement: 12.902162%\n" ] } ], @@ -657,7 +930,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 36, "metadata": { "editable": true, "slideshow": { @@ -671,7 +944,19 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -703,7 +988,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -712,6 +997,9 @@ "text": [ "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", + " warnings.warn(\n", + "WARNING:pydvl.value.semivalues:PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", " warnings.warn(\n" ] } @@ -749,7 +1037,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 38, "metadata": { "editable": true, "slideshow": { @@ -763,7 +1051,19 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -808,7 +1108,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -817,13 +1117,16 @@ "text": [ " 0%| | 0/100 [00:00\n", " \n", " \n", - " Imagine Dragons\n", - " -2.070629e-320\n", - " 0.0\n", + " blackbear\n", + " -0.990980\n", + " 0.382693\n", " \n", " \n", - " Lil Pump\n", - " -2.070629e-320\n", - " 0.0\n", + " CNCO\n", + " -0.985361\n", + " 0.309928\n", " \n", " \n", - " Tom Walker\n", - " -1.156114e-321\n", - " 0.0\n", + " Adele\n", + " -0.954124\n", + " 0.429572\n", " \n", " \n", - " Anuel AA\n", - " -1.057300e-321\n", - " 0.0\n", + " Ava Max\n", + " -0.803257\n", + " 0.307395\n", " \n", " \n", - " Doja Cat\n", - " -9.634280e-322\n", - " 0.0\n", + " Ariana Grande\n", + " -0.786560\n", + " 0.301802\n", " \n", " \n", "\n", "" ], "text/plain": [ - " data_value data_value_stderr\n", - "Imagine Dragons -2.070629e-320 0.0\n", - "Lil Pump -2.070629e-320 0.0\n", - "Tom Walker -1.156114e-321 0.0\n", - "Anuel AA -1.057300e-321 0.0\n", - "Doja Cat -9.634280e-322 0.0" + " data_value data_value_stderr\n", + "blackbear -0.990980 0.382693\n", + "CNCO -0.985361 0.309928\n", + "Adele -0.954124 0.429572\n", + "Ava Max -0.803257 0.307395\n", + "Ariana Grande -0.786560 0.301802" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
data_valuedata_value_stderr
BLACKPINK-0.7273400.221131
Kendrick Lamar-0.6051230.227634
CNCO-0.5610160.223759
Zedd-0.5525040.219483
Ariana Grande-0.5518000.215216
\n", + "
" + ], + "text/plain": [ + " data_value data_value_stderr\n", + "BLACKPINK -0.727340 0.221131\n", + "Kendrick Lamar -0.605123 0.227634\n", + "CNCO -0.561016 0.223759\n", + "Zedd -0.552504 0.219483\n", + "Ariana Grande -0.551800 0.215216" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -930,12 +1299,24 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 41, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABm0AAAKUCAYAAADmT3ztAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5glVbWw8XfNDEHSkCQjQZSkoiAgICpgFjOIGSMqehUjiterGFE+cw4ooGBGTJgAMSACooACZpCgJIEBVOLs74+1j11zpnumu6e7q2r6/T3PebpPVZ3utetU3GvvXVFKQZIkSZIkSZIkSe2a03YAkiRJkiRJkiRJMmkjSZIkSZIkSZLUCSZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiSJiHhIRJSIeEvbsUyXiHhOLeNzJvi5EhGnTVEMl0TEJRNYfvP6/4+e6f/dpoh4Sy33Q9qORZIkSZpJJm0kSZKkDouIN9bK6xIRWy/D35myyv8x/v6kEiJd0KdkhiRJkqTl27y2A5AkSZI0uogI4AVAAQJ4IfCaafp3ZwHbAtdO09/vgm8AvwT+0XYgE3AF+b0saDsQSZIkSdPPnjaSJElSdz0c2Bw4BrgSODAiVpyOf1RK+Xcp5fellOU2aVNKWVDL2JsESCnl9hpznxJNkiRJkibJpI0kSZLUXS+sPz8NHAesCzxxtAWbzwCJiKdHxJkRcXMd+ustwMV10QMbw639dzizsZ5pExFbRsSnIuLPEfGfiLguIn4bEZ+IiHXqMqcBn6sf+dzQ39+8LrN6RLwpIn4XETdGxE0R8ZeI+HJE7LS0FRERX6x/7x5D04+p008Zmr56RNweET9tTFtkCLdBmYHNgM2G4j56lBjWreviHxFxa0RcEBHPXVrsY5Rn1Yg4MiIurX/rzxFxaO1d1VxuzGHtIuKeEfH1iLg+Iv4VEb+IiMcsbai68f7vJcT++4i4LSLWHWP+ofX/v6wxba+67i6s3/9/6rbw5ohYeZz/d4lD/EXEafX7HG3eIyLipIi4tpb5L3UdrDnKsvep29slddlrIuLXEfGBiFhhPLFKkiRJk+XwaJIkSVIHRcT6wOOAP5ZSfhERNwKvBg4CvryEj74aeBjwbeDHwHzgNGBN4BXAecCJjeXPXUIMGwJnA2sAJwFfB1YGtgCeBXwE+CdwNHAD8Hjgm0N/84aaDPg+sDtwBvAZ4A5gE2Av4GfAOUsoE8ApwFOBfYA/NabvU3/uHhErl1Juqe8fTN7vLJLMGXIJcDhwSH3/gca8cxddlDWB04HbgK8BKwH7A5+NiIWllGOWEn/TCsAPgI2A75Hr4gnAEeT6PXxpfyAitgF+AawFfBc4H9iSHALupOn832TPr3cCTwM+PMr8A8n1dHxj2qHAIObv1v+1B/AW4CER8dBSyp3j+N8TFhFvrv/nOuA7wNXAfcihBh8dEbuVUm6sy94HOJMckvBbZLJzDWAr4GDgf4HbpyNOSZIkCUzaSJIkSV31XLKC/WiAUsrvIuIcYK+I2KqU8ucxPrc3sFsp5TfNiRFxCZm0ObeU8pZxxrAfsDZwSCnlg0N/b1VgYY3t6NpJ4/HAiaWUo4eWvTeZsDmxlPLEoXlzyMTS0pxaf+4DfKJ+dmtgY+BHZKJqD0aSNPsMfW4xpZRLgLcMeqQsZb3sABwFvGiQXIiID5DJkkPJRMZ4bUQmzx5WSvlP/VuHA38EXhkR7yylLC0x8FEyYXNwKeXjg4kR8SiWnLSZiv/9eeDtZHJmkaRNROxMPoPnhFLKdY1ZBwMXl1LK0PJvIxMh+7HkZOSkRMReZMLmDODRpZQbGvOeQ/YQOxx4ZZ18IJlQekIp5ZtDf2st4N9THaMkSZLU5PBokiRJUsfUnikvIJMixzZmHQ0EI8OmjeZTwwmbKfCf4QmllH8NKv2X8e8sLKVcv7QPllL+SvaM2asxjNcgMfN/wJ2N94N5/wJ+OcEYx/Jv4FXN3iCllAvJ3jfbRsRqE/x7L2+uv1LK1WQvpfnA1kv6YERsSibn/gx8sjmvlPI94OTp+t91+cvJ5NhOEbH90OwD689jhj7z1+GETfX++vMRS/u/k/Ty+vOFzYRNjeloskfVM0b53Gjb6vWllIVTHJ8kSZK0CJM2kiRJUvfsDdwd+FEp5YrG9OPJYaees4Rna5w1hXF8C7gZ+Gh9dspBEbH9eJ990nAhWTn+tIg4PSJeFxG7R8SKE/w7pwLrAPet7/cG/lFK+SU5vNo+ABFxV+BewM/H0WtkvP40GEJryGX151oT+FsLxugpNd6/dd/684wxkgg/n8b/PXB0/TlI0lC/z6eRw48t0tunPkfnsIg4OyIWRMTC+vyZf9ZFNh7n/52o3cjhzPaPfO7TIi9gReCuUZ/PRPb2uRM4MSKOjYhnR8Tdpyk2SZIkaTEOjyZJkiR1z0H159HNiaWU6yLi28CTyaHIvjbKZ6+cqiBKKX+LiF3I4aUeCTypzrosIv5fKeVD4/w7d0bE3mSPmP2Ad9dZN0XEMcAbSik3j+NPnQI8D9gnIs4jn4dzUmPe6yJiPpnMCZb8PJuJumGM6XfUn3Nn8G8NhpO7aoz5Y02fiv898A3gRuCZEfGG2gNpX3I4vQ+UUgZ/j5pgPBXYBfgdmRi5hpFnw7yZfEbQdFiHvO9981KWWw34ZynlrIjYE3gjua0+CyAi/gAcXkr54jTFKUmSJAH2tJEkSZI6pfYSeUJ9+8WIKM0XmbCBkcTOsNGGoJq0UspFpZQDyMrv+wOvJ+8jPhgRz5/A37m+lPLKUsqmwD3I4d9+D7wM+PgSPzxi8Hyah5K9TdZmJDFzKplw2ItxPM+m5wY9ftYfY/5Y06dMHV7tK8CG5POEYIyh0cgE4y7A0aWUe5dSDiqlvLE+Q+iTjN+gV9FYjQ/XHGXaAuD6Ukos5fW3RtnOKKXsS/Y62gN4G7lOj4+Ih04gXkmSJGnC7GkjSZIkdcuB5JBN55BDio3mccBDI2KLUsrF4/y7g2exTKRHyH/VnhPnAOdExC+An5LJpaMm+vfr8Fx/jojjyaG0Hj/OGK6MiAuBPcmePzCStDkduJVM2OwNXA+M99k+d5LrvC/OrT93i4g5owyR9sAZiuNoMvl2YEScAzwKOL+Ucu7QclvVnyeM8jcePIH/N3j20abDMyJiDeCeo3zml8BjImL7UsoFE/hflFJuBX4B/CIi/kQ+X+rxLP2ZQZIkSdKk2dNGkiRJ6pYX1p8Hl1JeMNqL7J0QZIX5eF1P9sK523g/EBE71eHGhg16cvy7MW3wbJLF/n5EbBERW47yd9Yih8Va7KHvS3AqsArwCvI5M5fBf3t+nAE8hXwe0GkTeGj8P8nnmtxlAnG0ppRyKXAamQx5UXNeRDyS7Ik0E3GcDvyJTGS8GFiBoSH9qkvqz4c0J9Zt4t3DCy/h/91E9s7aIyK2a/yducD7gNG+v/fXn5+OiI2GZ9Zn7Tyg8X73MbaD0bZ5SZIkacrZ00aSJEnqiIh4CNlb4LellLOWsOhR5DM3nhsRb24+P2QspZSbI+JMYM+IOA74I9nD5FullPPH+NizgBdFxM+Bv5CJn7sDjyV7tXygsewZZIX2IfWh7oNn63wY2AE4ISLOBi4C/g7clazsX4EJVNyTPWteBqzH4j03TmEkMTCR59mcAuwMfD8ifkqW7bxSyrcn8Ddm2kvJ3kUfi4hHA+cDW5LD532TXLfjTVoti2PJ4cPeRD4X57hRlvk28GfgVRFxb7IH1N3IZ+B8lwkkEoEjye3/9Ij4KnALOSTeCsB55Lb2X6WUUyLi9cC7gD9FxEnAxeQzbDYje/r8nJGeW68D9o6In9Xlbga2J3sRXQ98agKxSpIkSRNm0kaSJEnqjkEvm88saaFSyiURcTL5LJHHkg+FH49nkT0PHgk8jeytczlZ4T+aL5I9YXYHdiJ7MlwBfAl4bynld42Yro+IJ5MPfH8OsGqd9QXgV8ARZAX5I8keNteQw619qJTyvXHGD9nDZCE5asDwM2tOIRMIjDJvSd5OPg/lseQzTOaSz2XpbNKmlHJhROwGvJMcDm5v8nt8IrAtmbS5cey/MGWOBQ4nkybfKaVcPUqs/4qIvclt4CHk8HZ/Jb+r9wEHjPeflVI+GxEBvIocSvB6Mkl1GPD1MT7z7og4HXg5OXTc48ln3VxBJmGObyz+sfo3d63LziP3kY+R2/zfkCRJkqZRlDKlzymVJEmSJLWo9qR6OrBNKeUPbccjSZIkafx8po0kSZIk9UxEzImIDUaZvg/Zc+VCEzaSJElS/zg8miRJkiT1z4rAZRHxY+D35PNktieHzLuNfOaNJEmSpJ5xeDRJkiRJ6pmImAt8gHyWzSbAKsC1wE+BI0opv2kvOkmSJEmTZdJGkiRJkiRJkiSpA3ymjSRJkiRJkiRJUgf4TJtpEBEBbATc1HYskiRJkiRJkiSpE1YH/l6WMASaSZvpsRFwedtBSJIkSZIkSZKkTtkEuGKsmSZtpsegh80m2NtGkiRJkiRJkqTZbnWys8cScwYmbabXTaWUG9sOQpIkSZIkSZIktSefqrJ0c6Y5DkmSJEmSJEmSJI2DSRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB5i0kSRJkiRJkiRJ6gCTNpIkSZIkSZIkSR1g0kaSJEmSJEmSJKkDTNpIkiRJkiRJkiR1gEkbSZIkSZIkSZKkDjBpI0mSJEmSJEmS1AEmbSRJkiRJkiRJkjrApI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB5i0kSRJkiRJkiRJ6gCTNpIkSZIkSZIkSR1g0kaSJEmSJEmSJKkDTNpIkiRJkiRJkiR1gEkbSZIkSZIkSZKkDjBpI0mSJEmSJEmS1AEmbSRJkiRJkiRJkjrApI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdUDvkzYR8dKIuCQibomIMyNil6Usv39E/L4u/9uIePQSlv1ERJSIOGTKA5ckSZIkSZIkSWroddImIg4A3gccDuwInAf8ICLWG2P53YEvAkcB9wNOBE6MiHuNsuwTgQcAf5+W4CVJkiRJkiRJkhqilNJ2DJMWEWcCZ5dSXlbfzwEuAz5cSjlilOW/DKxaStm3Me2XwLmllBc3pm0MnAk8Avgu8IFSygeWEMdKwEqNSasDlwPzSyk3Tr6EkiRJkiRJkiSp7yJiDWABS8kb9LanTUSsCOwEnDyYVkpZWN/vNsbHdmsuX/2guXxN/HweOLKUcsE4w3kDubIHr8vH+TlJkiRJkiRJkiSgx0kbYF1gLnDV0PSrgA3G+MwG41j+UOAO4EMTiOVdwPzGa5MJfFaSJEmSJEmSJIl5bQfQJRGxE/AKYMcygXHjSim3Arc2/s40RCdJkiRJkiRJkpZnfe5pcy1wJ7D+0PT1gSvH+MyVS1l+T2A94NKIuCMi7gA2A94bEZdMRdCSJEmSJEmSJEmj6W3SppRyG3AOsM9gWn0ezT7AGWN87Izm8tXDGst/HrgPcN/G6+/AkcAjpiRwSZIkSZIkSZKkUfR9eLT3AcdExK+As4BDgFWBzwFExLHAFaWUN9TlPwj8JCJeDXwXeCpwf+AggFLKP4F/Nv9BRNwOXFlK+cO0l0aSJEmSJEmSJM1avU7alFK+HBF3Bd4KbACcCzyylHJVXeRuwMLG8r+IiKcDbwfeCfwJeEIp5XczGrgkSZIkSZIkSdKQKKW0HcNyJyLWABYA80spN7YdjyRJkiRJkiRJas948wa9faaNJEmSJEmSJEnS8sSkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB5i0kSRJkiRJkiRJ6gCTNpIkSZIkSZIkSR1g0kaSJEmSJEmSJKkDTNpIkiRJkiRJkiR1gEkbSZIkSZIkSZKkDjBpI0mSJEmSJEmS1AEmbSRJkiRJkiRJkjrApI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB5i0kSRJkiRJkiRJ6gCTNpIkSZIkSZIkSR1g0kaSJEmSJEmSJKkDTNpIkiRJkiRJkiR1gEkbSZIkSZIkSZKkDjBpI0mSJEmSJEmS1AEmbSRJkiRJkiRJkjrApI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB5i0kSRJkiRJkiRJ6gCTNpIkSZIkSZIkSR1g0kaSJEmSJEmSJKkDTNpIkiRJkiRJkiR1gEkbSZIkSZIkSZKkDjBpI0mSJEmSJEmS1AEmbSRJkiRJkiRJkjrApI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOqD3SZuIeGlEXBIRt0TEmRGxy1KW3z8ifl+X/21EPLoxb4WIeHed/q+I+HtEHBsRG01/SSRJkiRJkiRJ0mzW66RNRBwAvA84HNgROA/4QUSsN8byuwNfBI4C7gecCJwYEfeqi6xS/87b6s8nAVsD35q+UkiSJEmSJEmSJEGUUtqOYdIi4kzg7FLKy+r7OcBlwIdLKUeMsvyXgVVLKfs2pv0SOLeU8uIx/sfOwFnAZqWUS8dYZiVgpcak1YHLgfmllBsnVThJkiRJkiRJkrRciIg1gAUsJW/Q2542EbEisBNw8mBaKWVhfb/bGB/brbl89YMlLA8wHyjADUtY5g3kyh68Ll/CspIkSZIkSZIkSYvpbdIGWBeYC1w1NP0qYIMxPrPBRJaPiJWBdwNfXEqPmXeRyZ3Ba5MlRi5JkiRJkiRJkjRkXtsBdFVErAB8BQjgJUtatpRyK3Br47PTG5wkSZIkSZIkSVru9Dlpcy1wJ7D+0PT1gSvH+MyV41m+kbDZDNjb59JIkiRJkiRJkqTp1tvh0UoptwHnAPsMpkXEnPr+jDE+dkZz+ephzeUbCZt7AA8tpfxzCsOWJEmSJEmSJEkaVZ972gC8DzgmIn4FnAUcAqwKfA4gIo4FriilvKEu/0HgJxHxauC7wFOB+wMH1eVXAL4G7AjsC8yNiMHzbq6riSJJkiRJkiRJkqQp1+ukTSnlyxFxV+CtwAbAucAjSylX1UXuBixsLP+LiHg68HbgncCfgCeUUn5XF9kYeFz9/dyhf7cXcNrUl0KSJEmSJEmSJAmilDK5D0bMBfYnkxnrAf9XSvltRMwnhyA7vZE8mVUiYg1gATDf5+FIkiRJkiRJkjS7jTdvMKln2kTEmsDpwPHA08jeKXets28GPgS8YjJ/W5IkSZIkSZIkaTaaVNIGOALYHngEsCUQgxmllDvJ58I8epmjkyRJkiRJkiRJmiUmm7R5AvDhUsqPgNHGV/sjsPkk/7YkSZIkSZIkSdKsM9mkzXzg4iXMXwGYN8m/LUmSJEmSJEmSNOtMNmnzF2DHJcx/OHDhJP+2JEmSJEmSJEnSrDPZpM1ngOdFxAGMPM+mRMRKEfEO4JHAJ6ciQEmSJEmSJEmSpNlgskOYfRDYHvgicEOddjywTv2bnyylHLXM0UmSJEmSJEmSJM0SUUqZ/IcjHgjsB9yD7LXzF+ArpZSfTk14/RQRawALgPmllBvbjkeSJEmSJEmSJLVnvHmDyfa0AaCU8nPg58vyNyRJkiRJkiRJkjT5Z9pIkiRJkiRJkiRpCk2qp01EXAwsbVy1Ukq5+2T+viRJkiRJkiRJ0mwz2eHRfsLiSZu5wGbAHsDvgN8sQ1ySJEmSJEmSJEmzyqSSNqWU54w1LyJ2AH4AHDfJmCRJkiRJkiRJkmadKX+mTSnlPOCTwLun+m9LkiRJkiRJkiQtr6Y8aVNdBWw3TX9bkiRJkiRJkiRpuTPlSZuIWAd4PnD5VP9tSZIkSZIkSZKk5dWknmkTEaeOMWtNYBtgReBZk4xJkiRJkiRJkiRp1plU0obsoVOGphXgYuBk4LOllN8vS2CSJEmSJEmSJEmzyaSSNqWUh0xxHJIkSZIkSZIkSbPalD/TRpIkSZIkSZIkSRM3rp42EfHsyfzxUsqxk/mcJEmSJEmSJEnSbBOlDD+aZpSFIhZO4m+XUsrcSXyu9yJiDWABML+UcmPb8UiSJEmSJEmSpPaMN28w3mfabDElUUmSJEmSJEmSJGlU40ralFL+Nt2BSJIkSZIkSZIkzWZz2g5AkiRJkiRJkiRJ4x8ebTERsQHwfGBHYD6LJ4BKKWWfZYhNkiRJkiRJkiRp1phU0iYi7gOcBtwF+ANwb+BCYE1gY+AvwGVTEqEkSZIkSZIkSdIsMNnh0Y4Abga2Bh4KBPCKUsqmwAHAWsDrpyRCSZIkSZIkSZKkWWCySZs9gE+WUi4FFjb/Vinlq8BxwJHLHp4kSZIkSZIkSdLsMNmkzRzgqvr7DcCdwNqN+b8Fdpp8WJIkSZIkSZIkSbPLZJM2FwNbAJRSFtb3D23M351M5kiSJEmSJEmSJGkcJpu0+SGwf+P9x4EXRMTJEXEKcCBw/LIGJ0mSJEmSJEmSNFtEKWXiH4pYC9gSOL+UcntEBPBG4MnkUGnfAd5ZSrltKoPti4hYA1gAzC+l3Nh2PJIkSZIkSZIkqT3jzRtMKmmjJTNpI0mSJEmSJEmSBsabN5jU8GgRcXBE3HWywUmSJEmSJEmSJGlRk32mzUeAKyLiRxHx/IhYeyqDkiRJkiRJkiRJmm0mm7TZBng7sCHwaeAfEXFSRDyrdvGRJEmSJEmSJEnSBCzzM20iYnvgqcD+wD2BW4EfAF8qpXxpmSPsIZ9pI0mSJEmSJEmSBsabN1jmpM3QP92BTOAcDKxaSpk3ZX+8R0zaSJIkSZIkSZKkgfHmDSY7PNpo//A+wFOA/YDVyR43kiRJkiRJkiRJGodl6gkTEdsBB5DJmnsCt5NDo70Z+NYyRydJkiRJkiRJkjRLTCppExFvIhM12wF3AqcARwAnllIWTF14kiRJkiRJkiRJs8OknmkTEbcDPwG+DJxQSvnnVAfWZz7TRpIkSZIkSZIkDYw3bzDZ4dE2LqVcPcnPSpIkSZIkSZIkacicyXzIhI0kSZIkSZIkSdLUmlTSRpIkSZIkSZIkSVPLpI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqgHElbSLicRGx0XQHI0mSJEmSJEmSNFuNt6fNN4CHDN5ExF8j4nHTEpEkSZIkSZIkSdIsNN6kzU3Amo33mwOrTXUwkiRJkiRJkiRJs9W8cS53FvDGiFgfWFCnPToiNljCZ0op5f3LFJ0kSZIkSZIkSdIsEaWUpS8UsRVwLPCAOqkAsZSPlVLK3GULr58iYg0yuTW/lHJj2/FIkiRJkiRJkqT2jDdvMK6eNqWUPwO7R8TKwHrAJcAhwDeXOVJJkiRJkiRJkiSNe3g0AEoptwCXRsThwKmllL9NT1iSJEmSJEmSJEmzy4SSNgOllMOnOhBJkiRJkiRJkqTZbFJJG4A6VNqTgR2B+cCcoUVKKeX5yxCbJEmSJEmSJEnSrDGppE1EbAb8GNgcuIFM2lwHrAnMBa4Fbp6KACVJkiRJkiRJkmaD4d4x43Ukmah5AHBPIIADgNWAQ4H/AI+YigAlSZIkSZIkSZJmg8kmbfYGPlZKOQtYWKdFKeXWUsqRwCnAB6YgPkmSJEmSJEmSpFlhskmbVYBL6u83AoXseTNwBvDAyYclSZIkSZIkSZI0u0w2aXMpsAlAKeUO4ApyqLSB7YBbli00SZIkSZIkSZKk2WPeJD93KvB44PD6/mjgDRGxFpkIehZw7DJHJ0mSJEmSJEmSNEtMNmlzBLBzRKxUSrkVeCewEbAfcCdwPPCqqQlRkiRJkiRJkiRp+RellLZjWO5ExBrAAmB+KeXGtuORJEmSJEmSJEntGW/eYLLPtJEkSZIkSZIkSdIUmuzwaNTn1zwN2BJYC4ihRUop5fnLEJskSZIkSZIkSdKsMamkTUQ8AvgasCpwI3D9KIs57pokSZIkSZIkSdI4TbanzXuBK4EnlVJ+O4XxSJIkSZIkSZIkzUqTfabNVsCHTNhIkiRJkiRJkiRNjckmbf4ErD6VgUiSJEmSJEmSJM1mkx0e7X+Bj0bE8aWUS6YwHi2nNn/9d+cCewIbAv8AfnbJEY+5s92oJqbvZeh7/ND/MvQ9frAMXdD3+KH/Zeh7/ND/MvQ9frAMXdD3+KH/Zeh7/GAZuqDv8UP/y9D3+MEydEHf44f+l6Hv8UP/y9D3+GH5KEMXRCll6QtFfGiUyXsC2wA/Ai4Dhld+KaW8Ypkj7KGIWANYAMwvpdzYdjxt2/z1330S8EFgk8bky4FXXHLEY05oJ6qJ6XsZ+h4/9L8MfY8fLEMX9D1+6H8Z+h4/9L8MfY8fLEMX9D1+6H8Z+h4/WIYu6Hv80P8y9D1+sAxd0Pf4of9l6Hv80P8y9D1+WD7KMN3GmzcYb9Jm4SRiKKWUuZP43IRExEuB1wIbAOcB/1NKOWsJy+8PvA3YnBzm7dBSykmN+QEcDrwQWBM4HXhJKeVPE4jJpE1Vd9av1bfRmDXY8Pbr+k7b9zL0PX7ofxn6Hj9Yhi7oe/zQ/zL0PX7ofxn6Hj9Yhi7oe/zQ/zL0PX6wDF3Q9/ih/2Xoe/xgGbqg7/FD/8vQ9/ih/2Xoe/ywfJRhJkxp0qarIuIA4FjgxcCZwCHA/sDWpZSrR1l+d+CnwBuA7wBPBw4Fdiyl/K4uc2idfyBwMZnguTewXSnllnHGZdKG/3aHuwTYmEV31oFCZlu36Go3ub6Xoe/xQ//L0Pf4wTJ0Qd/jh/6Xoe/xQ//L0Pf4wTJ0Qd/jh/6Xoe/xg2Xogr7HD/0vQ9/jB8vQBX2PH/pfhr7HD/0vQ9/jh+WjDDNltiRtzgTOLqW8rL6fQw7V9uFSyhGjLP9lYNVSyr6Nab8Ezi2lvLj2svk78N5Syv+r8+cDVwHPKaV8aYw4VgJWakxandwQZ13SZvPXf3cHYPv6dlvy+UdL83bgovr7BZcc8ZjzpiO28ep7GfoeP/S/DH2PHyxD/d3taBn1vQx9jx/6X4a+xw+Wof7udrSM+l6GvscPlqH+7na0jPpehr7HD5ah/u52tIz6Xoa+xw/9L0Pf44flowxtGG/SZt4k//ipZCLjFWP0aHkocFgpZe/J/P1xxrAisBPwrsG0UsrCiDgZ2G2Mj+0GvG9o2g+AJ9TftyCHWTu58TcX1OTQbsCoSRuyZ86bJ1iE5dUHgQdP8DPNnfonwEOmLJrJ6XsZ+h4/9L8MfY8fLAO0X4a+xw/9L0Pf44f+l6Hv8YNlgPbL0Pf4of9l6Hv8YBmg/TL0PX7ofxn6Hj9YBmi/DH2PH/pfhr7HD/0vQ9/jh+WjDJ01qaQNIyv0gRHxpFLK2UPz12fiX9pErQvMJZNHTVcB24zxmQ3GWH6DxnyWssxo3sWiyaBBT5vZ6BUsY5Z1OoKaoL6Xoe/xQ//L0Pf4wTJA+2Xoe/zQ/zL0PX7ofxn6Hj9YBmi/DH2PH/pfhr7HD5YB2i9D3+OH/peh7/GDZYD2y9D3+KH/Zeh7/ND/MvQ9flg+ytBZkxoeLSIWkl/Ek8gv52WllKMa858BHFtKmTtVgY4Sw0bAFcDupZQzGtPfAzy4lLLrKJ+5DTiwlPLFxrSDgTeXUtavz7w5HdiolPKPxjJfAUop5YBxxuYzbVg+xjPsexn6Hj/0vwx9jx8sQxf0PX7ofxn6Hj/0vwx9jx8sQxf0PX7ofxn6Hj9Yhi7oe/zQ/zL0PX6wDF3Q9/ih/2Xoe/zQ/zL0PX5YPsowU8abN5izDP/jEmAP4IvApyPiExEx2Z47k3EtcCfZq6dpfeDKMT5z5VKWv7Ixbbx/U2OoO+Er6tvh7ODg/SFd3ln7Xoa+xw/9L0Pf4wfL0AV9jx/6X4a+xw/9L0Pf4wfL0AV9jx/6X4a+xw+WoQv6Hj/0vwx9jx8sQxf0PX7ofxn6Hj/0vwx9jx+WjzJ0zbIkbSil3FpKeR7wEuBA4CcRseGURLb0/30bcA6wz2BaRMyp788Y42NnNJevHtZY/mIyOdP8m2sAuy7hb2oJLjniMScA+5G9opouB/ar8zut72Xoe/zQ/zL0PX6wDF3Q9/ih/2Xoe/zQ/zL0PX6wDF3Q9/ih/2Xoe/xgGbqg7/FD/8vQ9/jBMnRB3+OH/peh7/FD/8vQ9/hh+ShDlyzL8GjPLKUc35i2C/A18jk53wBePJ3Do9X/eQBwDPAi4CzgEOApwDallKsi4ljgilLKG+ryu5MPOXo98F3gqcBhwI6llN/VZQ6t8w8kkzhvA+4DbFdKuWWccTk82pDaTW5PYEPgH8DP+pZd7XsZ+h4/9L8MfY8fLEMX9D1+6H8Z+h4/9L8MfY8fLEMX9D1+6H8Z+h4/WIYu6Hv80P8y9D1+sAxd0Pf4of9l6Hv80P8y9D1+WD7KMJ3GmzeYsqRNnb4u8GVgL/IZMNOatKn/82XAa4ENgHOBl5dSzqzzTgMuKaU8p7H8/uRDjzYH/gS8rpRyUmN+AIcDBwFrAj8HDi6l/HECMZm0kSRJkiRJkiRJwPQnbQ4EflJKuWSUeXPI4dLWLaUcPuE/vhwwaSNJkiRJkiRJkgamNWmjJTNpI0mSJEmSJEmSBsabN5i3jP9kO2BLYC0ghmaXUsrnl+XvS5IkSZIkSZIkzRaTStpExN2BLwC7sHiyZqAAJm0kSZIkSZIkSZLGYbI9bT4J3Bs4BPgZcP1UBSRJkiRJkiRJkjQbTTZpswfwzlLKh6cyGEmSJEmSJEmSpNlqziQ/dy35wBxJkiRJkiRJkiRNgckmbT4BPDMi5k5lMJIkSZIkSZIkSbPVZIdH+yMwFzgvIj4LXAbcObxQKeWEZYhNkiRJkiRJkiRp1ohSysQ/FLFwHIuVUsqs7IkTEWuQw8fNL6Xc2HY8kiRJkiRJkiSpPePNG0y2p81ek/ycJEmSJEmSJEmSRjGppE0p5SdTHYgkSZIkSZIkSdJsNqftACRJkiRJkiRJkjT54dGIiA2A5wM7AvNZPAFUSin7LENskiRJkiRJkiRJs8akkjYRcR/gNOAuwB+AewMXAmsCGwN/AS6bkgglSZIkSZIkSZJmgckOj3YEcDOwNfBQIIBXlFI2BQ4A1gJePyURSpIkSZIkSZIkzQKTTdrsAXyylHIpsLD5t0opXwWOA45c9vAkSZIkSZIkSZJmh8kmbeYAV9XfbwDuBNZuzP8tsNPkw5IkSZIkSZIkSZpdJpu0uRjYAqCUsrC+f2hj/u5kMkeSJEmSJEmSJEnjMNmkzQ+B/RvvPw68ICJOjohTgAOB45c1OEmSJEmSJEmSpNkiSikT/1DEWsCWwPmllNsjIoA3Ak8mh0r7DvDOUsptUxlsX0TEGsACYH4p5ca245EkSZIkSZIkSe0Zb95gUkkbLZlJG0mSJEmSJEmSNDDevMFkh0eTJEmSJEmSJEnSFJpQ0iYiNoiI50fEgRGxTp22VUR8NSKuioh/RcTpEfHw6QlXkiRJkiRJkiRp+TRvvAtGxLbA6cCaddI1EfEI4HvAfOAP9e/tDHw3Ih5WSjltSqOVJEmSJEmSJElaTk2kp83/AXcA+5KJmd8D3wKuB+5RSrlfKeXewL2Aq4E3THGskiRJkiRJkiRJy62JJG32AD5eSjmplHIO8HpgE+B9pZQrBguVUv4IfBLYZUojlSRJkiRJkiRJWo5NJGmzIfCXxvvB75eMsuzFwBqTjEmSJEmSJEmSJGnWmUjSZi45PNrAnfXnwlGWHW2aJEmSJEmSJEmSxjCRpA1AGec0SZIkSZIkSZIkTUCUMr6cS0QsBG5h0d42qwH/YaTXzcA8YKVSytypCLJvImINYAEwv5RyY9vxSJIkSZIkSZKk9ow3bzBvAn/zmGWOSpIkSZIkSZIkSaMad9KmlPLc6QxEkiRJkiRJkiRpNpvoM20kSZIkSZIkSZI0DUzaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB0xL0iYiHh4Rp07H35YkSZIkSZIkSVoezZvoByLi/sDdgeuBn5ZSbmnMewpwKHA/4IYpilGSJEmSJEmSJGm5N+6kTUTMB74N7NGYfHVEPAq4BTgOuC9wBfBa4FNTF6YkSZIkSZIkSdLybSI9bd4KPBD4MvAzYAvgYOBoYD0ycfM84LhSyh1TG6YkSZIkSZIkSdLybSJJm8cBXymlPG0wISIuBI4CzgAeXkr51xTHJ0mSJEmSJEmSNCvMmcCyGwOnDE0bvP+QCRtJkiRJkiRJkqTJm0jSZh4wnJgZvL9masKRJEmSJEmSJEmanSYyPBrAqhGxduP94PfVh6YDUEq5btKRSZIkSZIkSZIkzSJRShnfghELgdEWjjGmU0qZO/nQ+isi1gAWAPNLKTe2HY8kSZIkSZIkSWrPePMGE+lpc/gyRyVJkiRJkiRJkqRRjTtpU0oxaSNJkiRJkiRJkjRN5rQdgCRJkiRJkiRJkiaQtImIDSLiQRGx2tD0FSLirRHxl4j4d0T8OiIeN/WhSpIkSZIkSZIkLb8m0tPm9cBXgduGpr8XeCOwFnABsDXw9Yh40JREKEmSJEmSJEmSNAtMJGnzYODbpZT/Jm0i4q7AwcBFwJallJ2B7YBrgFdPZaCSJEmSJEmSJEnLs4kkbTYle9I07Vv/xv8rpdwAUEr5G/A5YNepCFCSJEmSJEmSJGk2mEjSZmXg5qFpewIFOGVo+l/I4dIkSZIkSZIkSZI0DhNJ2lwM3Hdo2l7A30oplw1NXw24bhnikiRJkiRJkiRJmlUmkrQ5ATgwIg6IiE0j4o3AZsBXRln2AcBfpyJASZIkSZIkSZKk2SBKKeNbMGJV4Gdkb5sCBPAHYJdSyk2N5dYB/gYcWUo5fKoD7oOIWANYAMwvpdzYdjySJEmSJEmSJKk9480bzBvvHyyl/CsidgGeCGxJJmZOLKXcMrToxsCbga9NOGpJkiRJkiRJkqRZatw9bTR+9rSRJEmSJEmSJEkD480bTOSZNpIkSZIkSZIkSZom4x4eLSK+NcG/XUopj5/gZyRJkiRJkiRJkmalcSdtgH2BW4ArgRjH8o67JkmSJEmSJEmSNE4TSdpcAWwMXAscD3yplHLltEQlSZIkSZIkSZI0y4z7mTallE2BvYDfAG8CLouIkyPiuRGx+nQFKEmSJEmSJEmSNBuMO2kDUEr5SSnlRcAGwH7AP4GPAFdHxAkRsV9ErDQNcUqSJEmSJEmSJC3XJpS0GSil3F5K+WYp5QBgfWCQyPky8LopjE+SJEmSJEmSJGlWmFTSZqD2qnkE8HjgfsAtwCXLHpYkSZIkSZIkSdLsMm+iH4iIOcDDgKcBTwBWAU4GXgh8o5Tyr6kMUJIkSZIkSZIkaTYYd9ImInYHng7sD6wD/BI4DPhKKeXa6QlPkiRJkiRJkiRpdphIT5ufA/8BTgK+yMgwaHeLiLuN9oFSyq+XKTpJkiRJkiRJkqRZIkop41swYmHj7dI+FEAppcydbGB9FhFrAAuA+aWUG9uOR5IkSZIkSZIktWe8eYOJ9LR57jJHJUmSJEmSJEmSpFGNO2lTSjlmOgOZqIhYG/gw8FhgIfB14BWllJuX8JmVgfcCTwVWAn4AHFxKuarO3wF4PfBAYF1yCLhPlFI+OH0lkSRJkiRJkiRJgjltB7AMjgO2Bx4G7As8CPjUUj7zfjLJsz/wYGAj4ITG/J2Aq4Fn1r/9DuBdEfGyKY1ckiRJkiRJkiRpyLifadMlEbEtcCGwcynlV3XaI4GTgE1KKX8f5TPzgWuAp5dSvlanbQNcBOxWSvnlGP/ro8C2pZS9lxDPSmTPnYHVgcvxmTaSJEmSJEmSJM16432mTV972uwG3DBI2FQnk8Ok7TrGZ3YCVqjLAVBK+T1waf17Y5kPXLeUeN5AruzB6/KlLC9JkiRJkiRJkrSIviZtNiCHMfuvUsodZHJlgyV85rZSyg1D068a6zMRsTtwAEsfdu1dZHJn8NpkKctLkiRJkiRJkiQtolNJm4g4IiLKUl7bzFAs9wK+CRxeSvnhkpYtpdxaSrlx8AJumokYJUmSJEmSJEnS8mNe2wEMeS9w9FKW+StwJbBec2JEzAPWrvNGcyWwYkSsOdTbZv3hz0TEdsApwKdKKW8fb/CSJEmSJEmSJEmT1amkTSnlGuCapS0XEWcAa0bETqWUc+rkvcmeQ2eO8bFzgNuBfYCv17+zNXA34IzG394eOBU4ppTyxkkWRZIkSZIkSZIkaUKilNJ2DJMSEd8je8m8GFgB+Bzwq1LK0+v8jcneMs8upZxVp30ceDTwHOBG4MMApZTd6/x7kQmbHwCvbfy7O2tCabyxrQEsAObX4dIkSZIkSZIkSdIsNd68Qad62kzQM4CPkImZhWTvmZc35q8AbA2s0pj2ysayK5HJmYMb8/cD7go8s74G/gZsPqXRS5IkSZIkSZIkNfS2p02X2dNGkiRJkiRJkiQNjDdvMGfmQpIkSZIkSZIkSdJYTNpIkiRJkiRJkiR1gEkbSZIkSZIkSZKkDjBpI0mSJEmSJEmS1AEmbSRJkiRJkiRJkjrApI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB5i0kSRJkiRJkiRJ6gCTNpIkSZIkSZIkSR1g0kaSJEmSJEmSJKkDTNpIkiRJkiRJkiR1gEkbSZIkSZIkSZKkDjBpI0mSJEmSJEmS1AEmbSRJkiRJkiRJkjrApI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB5i0kSRJkiRJkiRJ6gCTNpIkSZIkSZIkSR1g0kaSJEmSJEmSJKkDTNpIkiRJkiRJkiR1gEkbSZIkSZIkSZKkDjBpI0mSJEmSJEmS1AEmbSRJkiRJkiRJkjrApI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB5i0kSRJkiRJkiRJ6gCTNpIkSZIkSZIkSR1g0kaSJEmSJEmSJKkDepu0iYi1I+K4iLgxIm6IiKMiYrWlfGbliPhoRPwzIm6OiK9HxPpjLLtORFweESUi1pyWQkiSJEmSJEmSJFW9TdoAxwHbAw8D9gUeBHxqKZ95P/BYYH/gwcBGwAljLHsUcP6URCpJkiRJkiRJkrQUUUppO4YJi4htgQuBnUspv6rTHgmcBGxSSvn7KJ+ZD1wDPL2U8rU6bRvgImC3UsovG8u+BDgAeCtwCrBWKeWGJcSzErBSY9LqwOXA/FLKjctQVEmSJEmSJEmS1HMRsQawgKXkDfra02Y34IZBwqY6GVgI7DrGZ3YCVqjLAVBK+T1waf17AETEdsD/Ac+uf2883kCu7MHr8nF+TpIkSZIkSZIkCehv0mYD4OrmhFLKHcB1dd5Yn7ltlB4zVw0+U3vMfBF4bSnl0gnE8y5gfuO1yQQ+K0mSJEmSJEmS1K2kTUQcERFlKa9tpjGEdwEXlVK+MJEPlVJuLaXcOHgBN01PeJIkSZIkSZIkaXk1r+0AhrwXOHopy/wVuBJYrzkxIuYBa9d5o7kSWDEi1hzqbbN+4zN7A/eOiP0Gf7b+vDYi3lFKefN4CiFJkiRJkiRJkjRRnUralFKuAa5Z2nIRcQawZkTsVEo5p07em+w5dOYYHzsHuB3YB/h6/TtbA3cDzqjLPBm4S+MzOwOfBfYE/jKhwkiSJEmSJEmSJE1Ap5I241VKuSgivg98OiJeDKwAfAT4Uinl7wARsTFwCvDsUspZpZQFEXEU8L6IuA64EfgwcEYp5Zf17y6SmImIdeuvF43yLBxJkiRJkiRJkqQp08ukTfUMMlFzCrCQ7D3z8sb8FYCtgVUa017ZWHYl4AfAwTMRrCRJkiRJkiRJ0pJEKaXtGJY7EbEGsACYX0q5se14JEmSJEmSJElSe8abN5gzcyFJkiRJkiRJkiRpLCZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB5i0kSRJkiRJkiRJ6gCTNpIkSZIkSZIkSR1g0kaSJEmSJEmSJKkDTNpIkiRJkiRJkiR1gEkbSZIkSZIkSZKkDjBpI0mSJEmSJEmS1AEmbSRJkiRJkiRJkjrApI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA0zaSJIkSZIkSZIkdYBJG0mSJEmSJEmSpA4waSNJkiRJkiRJktQBJm0kSZIkSZIkSZI6wKSNJEmSJEmSJElSB5i0kSRJkiRJkiRJ6gCTNpIkSZIkSZIkSR1g0kaSJEmSJEmSJKkDTNpIkiRJkiRJkiR1gEkbSZIkSZIkSZKkDjBpI0mSJEmSJEmS1AEmbSRJkiRJkiRJkjrApI0kSZIkSZIkSVIHmLSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZIkSZIkSZLUASZtJEmSJEmSJEmSOsCkjSRJkiRJkiRJUgeYtJEkSZIkSZIkSeoAkzaSJEmSJEmSJEkdYNJGkiRJkiRJkiSpA+a1HcBybvWIaDsGSZIkSZIkSZLUrtXHs5BJm+kxWPmXtxqFJEmSJEmSJEnqktWBG8eaGaWUGYxldojsXrMRcFPbsXTM6mQiaxP6u276Xoa+xw/9L0Pf4wfL0AV9jx/6X4a+xw/9L0Pf4wfL0AV9jx/6X4a+xw+WoQv6Hj/0vwx9jx8sQxf0PX7ofxn6Hj/0vwx9jx+WjzJMp9WBv5clJGbsaTMN6gq/ou04uqYxVNxNpZQxM4ld1vcy9D1+6H8Z+h4/WIYu6Hv80P8y9D1+6H8Z+h4/WIYu6Hv80P8y9D1+sAxd0Pf4of9l6Hv8YBm6oO/xQ//L0Pf4of9l6Hv8sHyUYZotdZ3MmYkoJEmSJEmSJEmStGQmbSRJkiRJkiRJkjrApI1m0q3A4fVnX/W9DH2PH/pfhr7HD5ahC/oeP/S/DH2PH/pfhr7HD5ahC/oeP/S/DH2PHyxDF/Q9fuh/GfoeP1iGLuh7/ND/MvQ9fuh/GfoePywfZWhVLOF5N5IkSZIkSZIkSZoh9rSRJEmSJEmSJEnqAJM2kiRJkiRJkiRJHWDSRpIkSZIkSZIkqQNM2kiSJEmSJEmSJHWASRtJkiRJkiRJkqQOMGkjSZI0RSIi6k+vsTQlGttUtB2LJElSn0XE1hFxt7bjUPdExEsiYre245AGrFCQpB6KiLn15/y2Y1F/NSqDd4qIldqOZzmxAkApZWHbgcyEiNi07RimWteSI6WUUn89sNVAppFJTkl90rXzhKQJ+S5wWkQc4L309GrUWazSdixLExHbAh8APhoRq7ccjgSYtJFmzPJ2cR8R60TEWm3HMR7LY2VQKeXO+ut3I2KzVoNRL0XEnFJKiYidgc8Bj+zrvtKx4+sxEfHViFit7UCmW0S8DHhH23FMtUaSpDPquv7soGVox7b5qTC4qX99RGzZdjBToVFRsUJErNB2PMvCHoQaiIh59ecOEbFh2/HMhMF2HxGrRsQO0M3zxLC+7K99iXNphs/L9pLtpnpufhlwEXA88IWIeGBE3KWleJbr7aNRZ/GpmhTp7D5fSrkIeAlwZCnlpnqee3FX49Xs4MYnTbPBzQ2wZd9bcjRu1B4KfBJ4ersRLV1ErFBKWdj4HnprlJuBBwC7A2u1ecHXqJi6X0SsU39fri9Al6ZW0m0YaeW24xlNoyfIa4Abgd/1qXdIcxtrVp60eWEdETsBBwCnALe0FccM2g/Yus/7e6MybsWIuHdEPKceW7vmHGAh8AzoR4XheETEthGxVinl9oh4EPBOYMc+b1MDjYqKzwFvi4gt+nTjP3yMjYiV2j5H9Gn9La9KKXfUX08GtmkzlpnS2O7fCnw9Il7cnN+l7XIolnkRsVZEbBARK7YW1CgiYvOIeGptQNSba88lGZyXI2Kz2ko/mtP7onFft0lEPCUinhERT46I9duObSqUUu4spXwfeBbwfGAT4AfAmyJiu0H5ZzCewXZz37pPPDoi7j+TMUy3iNidrDd6HXR7NIJSymdLKV+sb18HvBf4cq3/6pTGPcwqEfHwiFi17ZgmqlGG3l/3T5fOXGBITcvTTtu4uTkLOKSPB1PI76RRlo8A6wMXtBjSqIYuNF8F/DYifkReiD2o3eiWTa00ae4bZwFXAQ8aZd5MxjWomPomcFxErNa3G5Sp0Ehq7gKcAFxM7iNvjogHdSl509hPVgR+Bvy2lPKXdqMan8F2Xrf5tSPiWZHDGzw2IlZu+Ubgk2TC5nuN4+Xy7DvAfcgb3r57J/AL4NPALyLiZxHxpIhYo+W4ACilnAEcDRxak4O9vlaqie21gBcDZ0fEgeT+81Xg530/hzRuQlcAbiNv/I8Bnh4Ra7cZ23g1KpL2joiPAt+LiM9ExKMiYr2ZiKGxHjesMXW2ome2iIg5EXFX4HZgh7bjmW6N66WHAy8kk7BfaMyP2jisE8fjwT4SES8BfgpcCvwQ+EwtQ1e8i+zl8NK2A1lWjW1kz4g4mlzvlwNfjYgXRMSaLYY3IXV7HtzXfR34EvB58tro+Ig4OJaT4ZRLKdcBxwEvAv4MvJ4s80sjYoOZiKFx7/gU4PvkPvEd4HMR8dGIuM9MxDHdSim/AF4APCkiPhJ1NIIuJbwht/+BOuntwCfIc90nauxdaqwwuFb+OLmf9qqnel3PJSLm9f26fzp1aifR7NI8SEfE6vW1CSxyo9iJC+BlFRGPAhYAvyql/KvteCZp0MX7bcAawJtKKafVaXeJiIMi4p0RcUCLMTYTCJ8B3gRcBtxK9iZ4f0S8PWrX3L6IiD0i4uSI2Lqxb6xQb8x+DjwaRk3qzGSMK5LJvF2AlzemLxf78Hg0KumPJi/ujiETa68lb3oOizqsRtsa+8kpwKuALQbzZrqF2SQMKvEOAs4g1/Ox5D5/elv7d0TsD+wIfKCU8rc6revrcln9GFgJ2AP6t783Ktt2JPeDzwP7A88D7iATCEdHxG7RYivlxnZ0DDCvxrfYtVKjgrvT1/f1Zv0dwDrAhcBNZMLm7sA5pZQr63Jzu16W0Qy2q/r2JcBdgSuB3chj1fERsVe0NBTLeDQqkg4iK6j3JyvpH0I+C2DPoev4Kd/3o7bAj+zB+4WIOKsvCa/lSUTcq5m8LqUsLKVcA5xLbtNjDgu1PGhcLx0BnAQcV0q5ObJl8wOBH0XE14AntxZkNbTfvoPcZ18L/Al4JrBrdKABUUS8ldx2XllK+fBSlu30OaAep+6s57UvADuTle7vAJ5A9ubo3XC5EfF28t7gf8iGmu8hy3EY2dts3xbDW2aN66rXkZXyVwM/Aq4F3gecGBFPiGkeJaVx7/gB8pi6F/Bw4I/AY8hz35tqorzvTiCTUi8CngSdbIgR9do6ImLTUspFpZRXkwn7c4DHAV+KiEO7kIytdT+rktfTnyQbjHZWI8G9XkQ8HzgbOI0cOu+pbcbWaaUUX75afVFbWQI3A78kT1o7NObPaTvGSZZrbv05jxxC5iJgk+a8vr2A1YFfAx8F7lKn7QGcSA7b8i/gOuCgltf5s2sszx1sP+RJ7BryBuZMsmXXhm2v03GW62ByqKV/A0cCqzfmvZq80GxOC/LkvR3ZevyuMxTnXciK84XAC9teby19Vw8jW9ft05i2Edlya2Hdf14EbNaBWHcC/lLjvRV4+dD8zh17G/vzxvWc8WXyxn89svL318A96zLzZji2i+t3fARw98b0IG8CWl9/U/1dkDfwVwKfWtL31fUXWan1M2DL+n5uPYY+j7xxvpmssNim7e8SeBtZqXD/ttfbMpTh88AVwOb1/X3qtcPN5FCNxwD3aCw/OLdvCGzadvzjKN8g3lfW4+v/IxM3e5DXvBcC/wHeD9wbWKHtmIfij/pzFbLB0VGD9U4OE3LNTGx/jTiOJyuzDh5lmV4cYyZa5q68yCTdQuDddVtdsTHvlcDfB+fa4XMuec+wWttlmKL1sCN5rf2yxrTX1OPYJcDvyev0J3Yg1nn1vPxxYOM67bnA9cDO9f0cYOs29h/y+u3fwOHAWnXaCvXnauQ13RPJCuvVZzq+SZRncJz6OJkce1B9vyF5L/oGYNU6bUbux6agLAF8rJ67Vm3M35TsIXUR8FeyknjntuOeRDkH9xL3A+6s39HKddpGZELhbLKX7CfJBokrTWM89wJ+A+w5NP0p5DCUl5ONpJ7XtXPEOMs3d+j9Z8nrvefWY1FnytTYBz4MvHeU+c+s38XlZJLvWR2Iece6nRw22vru4ousO7yeTNh8o/7+T2DXtmPr4qv1AHzNzhcjF/hPqRc0p5OtXL9F3rBfALwZWK/xmV7emAEfqgek39OoqO3SCWqc5QhgbbJS9Bt12jpkq4NBa5C71+/uhy3H+jOykmHD+v7lZEvee5MPHrwN+APZy2CnttftOMqzKvBQsgfHLcA/qEkR8qbrNuARwIPqhef3gL+RN9rnz1CMg0qquWRX8yuoN6993XcnUPbBxX8AjwTOB7ao05oVHA8EziNb8P8CuFcHYr8bOUb7pXV7+VbzgqleTHfu+wM+BfwOuHd9v3HdD17MSEL5scAeMxTPu8hK2N/V9Xh6jWXd4e2k7y/qjW3j/VfrcX/VJXxmNbJ1Wmdu7hm5DlmXfA7RYuetuk9vQSZKFpA3FNNe6dI4nm5AJjS2q8f4ncnWuwvJRPBjyeE8nkdWgL2OTBoeAzyu7XU8Rtk2rMeb/20cO18DfBE4kKygv7ae5w6nVvoCK5PDVFzWPK529UX2QPsbeS2yVnO7A7YlE1cLyWvDVzaOW505TpCNWy4Bdqvv1yWv2d/YiPclZCvlKU2SN7aNXcgK3hcyUqm2KjnMyjE1lm3aXldjlGGx6/zRptXpnUrcNeLairz2vJG81n8psBl5rXfvug3vNPjO6rwn1WPmRcB92i7DFK2HLeo6GFSKvaKeD04g7402qPv7hzoQ62Prfvvo+n79GvvbGvvQvuRQTDPeeI285jyPRgPNOn0+I40AF5KNib5FDxooAGuRlfzvb5yzvkheEw4S3iuR57792o53CeUYVFg/jDwXf6YR+9zGcrvW48J1wA/ajnsZyvteMsF576Hpc8iGbX9sbI//M8X/e3CdN5/spfeXwT5BPb/W39cgr5HOIu9zOnltN8Gyb0uOFPJnYKsOxBND23eQPYq/PfiuaFyb1WP+YWSd2K3AI1qM/aFk3dBfyJ7c8xrzOlXX2Njmn0LeMz+PkWu9P5L1R+vV9+sBq7Qdc1derQfga3a/6gHm89QWlWTG/Q4yEXAbWbH5HGa4xfQUlm8u2VLlP/WE/1OyBVHzwN+pA+ooZZgz9P4oskLl2/Xn74EnN+Z/op6I15vJOBv//571JHpEY9pVZA+uler7E+tF2sXAmm2v46WUJxq/r0c+hPqUuj2dBewN/JZsKfQv8sbsZ2Sr8IcBG0x3XI1pg5Zy96sx/bULF2PT+N0Mtyp9C9la5FxgfnO9DO3zL6nbXmsVjyze6mlXsgLsSrLl7PvpaE80svL2q/U1uMH8ITlU2vqD74Zstfam6T5/kBUitwOH1PcvrOvxFrJi/fE0KuSGj6l9ewGnkj1T1q3vn1mPR/dpLLM+eSNxWF3+urpM64nKUcpzBXBDPV7tPLxv1GVWAB4AvHgG41qxsd4GFVgL6/55Z2P6YJnrycTStWSL8LXbXrdjlGvNum+eRPbkuEc9bz2nzp9D9pY9lWxscQFZQf/CWr431uU61ZJwlGPqRmRLzKMa21DzfH5PslL79/W7/SEda4UNHFS3t0Fr+OPIXkJ3ayzzUabxmq+eiy4aHDvI52d9pG7zF9efX6ajSY8a8+Np9BAbPgeQFUSvIBurrTuTsY0z/ruQQ/Z8r67vU8meEHcnkwMfJp938VvyOvQmMrl6dNuxT+E6mEO2uF9I3rsuJBvlDe5fNyYb6B1L+70xH1iPKYMeH58je4Bs0VjmsHrs2a6F+P5fPY40GzXtUPfjhfVY+ALyOZkLGaMnb1dejFyH/pocHhdgzxr7UxmplNy5ns9e1kacEyjPjuQ1xkVkxXXze1pxaNlnALu3HfMylPV/aFy/ktddzfP0AeS99geAHacphmPI3quXAk9oTJ/HohXw25BD07e+3sZRpsE2/+S6Hx9MDuW+Y2OZdcn6vosYSuDOcKxrNH6f29ifX0te/6zISCOv4eTOfYA3t7yuNyXvh+9gZLSHbYaW6VRdI1kPdxIjIxAdVM9ZezTW/3voQC+mrrxaD8DX7H2RWdY/ULPT9aB4VT3YrEl2nbydvCE4gQ7fkI2jrNuTN7sLyQrdF9C46e3Di7yIfgjZYvposvXQCWSFyyBzfk/ypuXEGY4tht6/Crhv/f25ZAXWbo35HyJbrXS+tW6Nd/gGf7taxt8zUnH3MfKmZ/UlfXaq46kn2MVaz5OtLX9NXuzuWKd1qpJtitfJvHrRNPg+TmDoZni07Y0ZTEgPfW+rkT3lth2a/iTgB2QF8AXA6zuwbhfr7UOOG352/f3x5A3mYxi5UbgveTPwlhmI7/tk76rtGtPuQlY23lqPPx9hqMv3dOybM1DWuwE/qeU6ixyvfQcycfAlsifEOY394E6yIu8LwDPbjn+U8qwOHFrLtJBsjLB923HV2O5F9qJ5LtmD72lko49HkhWmfyLPxVuTrby3IIfgWpuRXhCdO+aSN8UfrOv7K+S1xDnUYXway21Qy39uXfY/wKmN+Z26CR2lnCvUsv2axrAqLFoBdhLZO+pJZGX3N2lUILT9Iq/TF5IVEzvV35/JSAONrcjhQb4yjTEcRvZo2KCeC04kezQcXucfTEcTwjW+3Wp8J5IVgM0W1M3hPq+py927jTjHWZa1yYTqBfUc8KF6HBo0Ivo8WfmyK9l6fFDR1bnj0ATLPahE2rzur5+r543mtdOj63Z6YPO7bSnee5CVja8iK/TuAJ7PSMO1u5HXqKe1FN+gt+g2je1qkBD8XxrJa7K3x0I62ohosH3U14nk9c4GZCOi7zDSanxFspfaVYzcE3XyHEbeH3ycbHy0sJ6n9mzMD3pcJzNU1gfV/eMYFk3WDPaVA8hGJtPWAJE8z55V1/XNZAK/mUhYpOFfndaL+wfymubPtVw31WPkX8kGbe8nR034Zz13DIYQnNH9op7DPs9QI17yGvxW4H5tr8clxN7cZh9I1sEtJIdKO4CWGlAPxTjcg2ku8DXg5DptFUYaVw/uXTYlE/vvoufXD1O2HtsOwNfsfNWd9sX1gmDbOu0wsnJr0Nphs3ogPwV4SdsxT7R8Y0x/PFm5dyfZIv+xNIbN6NqLkRuVp9QT1wsb89aiMUwOeYN2OFmxct+W4jyMvPmd15j2/LodDcZx3qCeLL7T9vqdQPkGN/brNKeRN8bvIZOf/yGfb3OXaYphBWqLiMa0pzPS8vvvZCu5D5JD3GxfT7Z/o7Y8W15e5LASf6Px3JrGvD3ISvyF9di1yEVT/d5a7TlI3hD8huzN+HvyZvkxjfmrkUMK/o3aNbylOO/C0PBmjf36uTX+p5A3yUcP9o8a/yFk6/1pbUVaz1N/Jbt4D5LXzV4125AtFReSF6CH0Wjt2scXWeHzbHIokMG57Ppaxn+TPWSPJJMM96RjY9I3vqdBheIq5BBM7yArTq8mkwWt3+wsoQx3IYeNuZSRZzgNytWXm/mnkD2cbq/HoD0ZpSKITCw/A3gUtbELHbqJI5NoP6IxhE/jOPU4MhnzYxZP2m5czxXvre/fXfenzgzZSl5L/azG/7tazhXrvBXJBki3AQ+eru+FbCz0L3LojAvIyp8XN+Y/hbyXeGjb62uM+OeQvXD/UvfXTwMPGWW5bRnlmT1tvxi9V/XdyF5Bg0rdLw1v32N9to8vltIjH9in7hvntR1rI6b/q/vm1cCZQ/NeTt7TPaq+n9HjKZnsvbhuP59npKHH5xrLDO57jiCHyuxkUnaoXDuTFdTn1WPW3o15DyLv/0+o7zu5b7BoJfC2dd8eHH/fyaLPa+zlKCijlPmddV/5HvDwxvR1yIZIly/tGDAV650cvv1v5HXRicBjh5bp5fomh8Rdm2xs9FKynuAXdb8f9CBfWM+NM5oMJBs7fb+u838Cr2rMm1+/+1cOfWYtcpSTjwAvanv9jlKmF5I9Xf9NNoB/CC0/W45GD6b6/j3A7+rv7yJHPNi2Mf9h5L31C9pen115tR6Ar9n7qifDp9XfVwZ+SbZeWqVO24YcTmzrtmOdQJmaB6Q5wP2plVaMtNpYmRy//Jr6OrZ5EdSV11BZXkVm7Qcthha7cCArJi8D3t1GnIx0RT90KPYH1wvOj5OtWd9NDlv0pLbX8TjLN6iIW5dscfYjFh0ffw0yifBlsvLrL9NxkqsXUz8jK6Hm12kb1v99GDncwdmMPIx1QX0/uBj7BCNDrHTyZmUC6+Jgcgii59b3qw3NX5GsxL+UTKZ9rl7gjfnMjxmIeVBB/SLy4vRHZMX7sfX7eQ/5nIBmy9F7ME3D640z5lfV2N48xvxj6ja/kEWTTi+s6/6oGYpzaxoJ1TptztC6fAxZ4XgHWQH6InpSud4oQ7O3wApkj783MdLj7wyW8ADJru335A3XMxvv1yKHdPsieQN/HrBfy/vtf5+XNbwOyedJLKAxFGiXX2Qr9eHWopeRlRSDc9dhtDBczzKW6111+39qfd/sSbF2nb+AbFzxAXLomQeQLUwXAg+ryz6qbnetP8h8aNt7MlmZsZBs8PI48tz/9vqdfXV425zK/19/fzTZK+uHZJJscF20FplsvZyOJYeH1wmZpPs0ee3wO7KRU+fvbxrbwQ5kD9ZB0m6Fui1/sm63vyGTeJu1HfMUlHlwvbQNI8/m+T3wGfLartkKfjNGhvjZtfn5lsuwST3GXEXea74HeBbZ8v0K4IstxhbksGGn1liuISus1xxsW/XnGrUMf6DlSsdRyjA4Bm3SmDaHbDD0b0aGbTyY7J31RzKhs1Hz83141WP+meS99C/JRrdrth3XFJZvI3KYzxvq/nIK+dyln5P3s2+bhv+52DVdfb8hWV9xXd03PkaHGnJMYflXqMeoDciGF/+vlvkVLcSyFvkohtPqfvs76j0lOUrOd8n6o/fVbePmutyNtHAOb2w7a5HJ4BeTCeMtG8eldciE903k9eehLcS5Vz3GN4+Rg+uHB5AJu5+R98XPbpRrc7Ju4tK2t9MuvVoPwNfseTUOJHvXg/NdGtNWIyuyftRYfj+y9e7eMx3rFJTxyWSSYwEjwwYs0nKXvIE7ql7cdWY4jEZ8gxu1x5MVc6cuYdmV6nf6fzQq9mY43jfWk8OW9f3g4L8i+aDBO8gK9OuBT7a9fidQrkE5vkwOE/OK5vfTWG7DetFx7nSc6Mhxf2+s2/RHyCE/RmsVvRXZCvPpZOvS95A3szcBz297fU7h+ti+8fsvycq44eTNOmSF3b/Jisn3A5u3GPM8smXjRxkZR/alZIXc/ev7ufW7bX3oQLKC6B3U4WKoD9VtzN+OHEv/72Sl0Rl1W/s3OcTbtFa2kz1J3sWiPWuGn3M0/JyLQxhqUdqHF9n44N1kD7rm8E6rkTcNHyBv6P9EDo+zZtsxL6U8KzEyHMurWbSCeIP63f68njd+Skd7xNZ9+TZGepJ2MhFIDnl7IVlpvUadtmE9P+xYX4PvY/Asw43bjHmC5duj8fs3GOr1SvYUOrueBwfPI1oAfLixPb6kfpe7zWTsjRibCYa5LFoxvQnZIn4wTN2gMcZnGHm21TJXQrKUxM/wfEaGv33DVMUwDet1HosOD9IcwuRnZKVuJ4d+YuSeZksyKfMbaqVzY5nVyITjj+v2eyY9G/55qDzN/eBsMrF8Qj3HDe7n7tlY5h7kef3BLcU7uFdbmUxyNJ9bszrZs/pU8t7nFrL18qGM9ExubZ8hk9obMzSKQOP3vciETief40FWmv6aTGBv05i+FZkcu5K8Hr2DrPx9cNvrfIxyNO+X78YYjW/IBqd/rvv5V7tWjgmUc1Oy0cuuNJ4hRjYO+CpZab+ATLS9eTpiqL+vRCaGNxlluV3JYeluqPtAaw+6n2Q570aONPEOskL+/izhOpq8RvwymRCZsV51Q9/HlmTDoQsZGeb8E3V7v4G81vhePabuwlBjvRmKt/k4gu+TDZ5ubJyb9mXR5yBtSyaaDmwh1hfV7/NWRmnQTSbuf09eE3+UHIL3sXW7X0BtCOWrrq+2A/A1+15kBecFDGWnyeFUriUrhI+sO/Iv2o53AuUaXDhvSl4c/4S8cX9ivWg7jZGK0uZJYoP6s/WWWaOUac16khrcoL+AJSRlZroMjLSG24Js/XZKY16weDfvF5Bjs3eqxdY4tqnd6knvhYy0QBvMG64Uvi/1wajTEM8KZCX54AHArx/vxRXZRfdWenbhOdZ30ng/GNP/inqht1hiqm57J9b11tqQS8DDyR4oj6vv168XRm+jDnVIdkn+ER1pLdvYx9er6++fwDMa89cE9icrf08lW2M/m2nuIVSPL4PW55ew6NCRizyoslmO+vtadLBV+FLK+2pGnsl2EHmea1aurEe2xhxUvP+kbkutJ/+WUKYtyYroS8lKt9Ua8+bUffv/gC+0Heto21/9eS/ypuhDbce0pFjJirlzB+uynkvWHlpuTt2Xf0/eiH6Z7FXRyYTZIOah9/clK7UuIW88n9SYtzLZoOc55PBE2zSOu7uRyapTZir20cpBNqZ6BplMOJNMWD6tsdw2dV/Zj8az7IbXwxTEs2Pd975FNnZ4IUM90smEzT+B7zW3ta5sE2Rr0WayZgUWvSZ9X913/w58tu24l1KmH5FJ7MFwWqMNmbZu3a5PajveKfr+Xl+3r8c35l1JDu2zZn2/WKXdTG6DQ/vtMfXYORjy9sGN5TYiewRvTyNBONP7CyMVjnMZo8K/UaY9yWfM/bbtbWIJ5dma7JF7FZm0PBhYvzH/XuQ9Z2eHxG18JxuQjSquqdv938lGXcPPSV2ffEbhQW3HPsly7sjIKBD/JCu6Xzd0bN6KTEbPn4Y4Btv3U8jK9KvIOqOvMEovY/J+5gymaejzKS7b4H5tD/L6YSGZsFxYj53vZ+R5w4PvIxrrZPv6nczokGPDx0GyF8hH6j5wC3l//4AlfaaFdf1zcrjFl5IJsrfW9bwvHWm8RV7zPpjsLfkfsj7x2Y35q5DXmycykni6nUyavrTt+Lv2aj0AX7PjxUgFw4ZkD5T/aR6w688tyKEXLiMz2j+k0XKlLy9y/NdzqA8uIytsbyMzzoMb9G3bim+CZVmRbOl0ZD3h/qN+d/NH+35binFePcnfUX8+gkUrSOcOn8DaPtlOoozvIpMk9xll3uBiZ+dp+t+LJRnIC9of1hPs6WQlVPNGcE5j/x4kmTYhe5t8sO31OQ3raF2yIvvHZPfuUxl9zPp71J+ttE4jWwbdTh2zmRy27U8s2jLzDWRvldbHDx/eT8mbnJPqdvcrGq0BGRl+ckaSBGRX9BvIm62TyV4mZ7Joi/vhMXyDkZuavh2DViWTfifX9f8D8uZgeFi4zeu+8Ou63CFtxz7W9lSn3Z2s4PoPo9wkkDcdK093bMtYrv+t63qPtmMZR6yr1Z/vq/vLU1m8h+Jq9Th0LdM0NMk0l3ETsuX1hfW8/TlglyUsfy+y8ua/zydqIebBdcQn6nHtLLJi7qK6bT12us9bjWPjA8kWzrfUnzcxcq3xbLJ18gpkb95XUpM5bZ1Xl/CdXga8lqFGNIzcBwyW+Qqwf9sxj1KGwb3ZA8nkUvO5bYN5w9fWcxvl61xDtAmUfSWy4cFR1OQy2TDkv89hrdO+R4vDGTb228/U7+hEcnjP8+o+820WfxbljFfoDe8Do8xvJjfnkteql5A9ux7S9vYwjvI9tx7vryIbGzyR0Uci6Ox1H/Cdun1/nLyGGzyb83xyaKhOVARPQTl/Xc8rh5CjiPyIvNY4Z/g4PNXHsMbxc2uykvpssrL9LYw8E/J9NBJ/dflRG2l29UUOZ3hm3Q+2J3vjH0XW0/yCUUacIOsNHlXXw74txT3cC+op9fw8GKqu1edrN867j6zbz/6NeWeTvfvuWt9vxRKuO2d4Xa5NNvQZNOo7h0YSjLxmfgA5jPhjBmXwNbRO2w7A1+x5kRVWg5YFz2tOH1puJ3LYm/ltxzyJMt61Hjjfx8iNy6CF2vr1/Zr1YPvctuOdQLnWJ4dJG1SY/oSswJvRB8aNEdua9QLz22QXy1+Qmf3hlu69veAkW/z9q3HhNnyjvB55EXrwVJeTfMj7N4CtRpn3aLJV8Z3kjcqjWbS1evOkvXr9bn7S9vqcwnUz/D1sQ158n08mEI+mIz1WanybkkmaN5G9DO4ge5+t0Jj/NeCnbcda4xlU4j2KfL5NkMn9/6nb5UKygqI5tMaMHZPIVvML6jH+/eTzHRaSw2BsNFyO5eFFJihfQN6U/ZtsQbUrjaHoyGT/DuTDXTdrO+Ya039vesnK3r1p9PQgh/e8g+xJ2IteUI0y7UwmB1ZpO6YlxDrYlweVFm8kkxSXkr0wF3uIPPmsiK8z8uywzlZ4NcvYeP8AclzuS8iWg29nlGGwyMr7dzM0/GML29GOZFL/NY1pJ5O9bQbDzq7F9CdvLqj/dy8yWbwyOZzTP+vrqY1lO3dsreepzRvnqB+TrUnXG1ruPmTjl9Z6346zPAeRlZp7DsrXLGv9+SxGaVTUxxdZeRh1uz++TtuK7Cn+Kkaul7Yhr7vf0HK8m5CV7a9pTNsReDP5rKc7afG5Z+S94t/IpMZn6/FlP/J+edNRlp9b5x9Fx4dHZ/GhYt9JJm6uIofTe0BbsY0z/sFxfh/yHvO5jXk/J5N/p9fj2PHUXhJ9fZE9YS8FntCYdre6X/+SrJw/cbrLSdZX/ALYsb7fox5fvk8mXy8GDqQHvWsaZRqcC55KNvxY7HqGbPwx6N00fD6cA+wOfLTFMmxct4e7D017Kdnb6TayzuP+La/rV5DDXA6GDn8h2cil2WjwU2SjmzafSztcv7sF+eyy8+sx5SuMkaAZ/qwvkza+ZvBFVvQMhtn6FUO9TehAAmCKyvkb4P319yfUC+ZHNk5oe9QLoVYz9pMs25bkDdz5ZAXXZ2fyIm6sgzhZSbg92cX54nrx+f9o8fkhU1zuJ9X95pUs+jDwZqXdBcD/TPH/3ZgcPuhPZCuTt452EUnehP27XowdSY5d2xw6KciKqQtpDBfTx9dQuVZklCQZmTT8BHmjeglZIbfIcH0zFOugorT5bILXMTIswOlDy7+SvHF4TNvreSiu88mE8RaN7WlHsgfa1TXmVipOyIvnM8gblfvWY+KNZOvwN4/2ffTtNRw32bvx7mQFxQ1kD8w3ka0Hm5UYrTzfbClleRsjYz//mnyI9q7kUCxHkufvd9JSSy9GkhorM0aSfozPrdW3bYwcjuXj5HAsF9b1fu+245pgGYbPcyuSlZHN6U8ie6ZdTlYET+l5egrL8n7y2nT7+n6vuq88qXEu+b+63LTs24y0IF1sLHPyeuRX5JAlO7S9vsZZnieRlYS3k9dSj2KkV+hLa1nv23acSynD4+t2sHt9P4fFW9GeQV7zdHY4zEmU+yvAr+rvx9fzxWaNdfD0ui0+uk5rc8SBL1F7UDemrVT34c/U65HbaSExTDasWUg+s+AUssHHArJy+pfkUIyvJh+mvWtdt51sZNc4Jzevc+ay6HMN71mPU7fUsr2FjtdvkEPrfY/a05NMmt1OJnPux8gzPhYCB7cd7wTL1jxWbVa3wcEzAJujctyXvAa8oJbzKdMUz33Ie+r/aZwLfkY2/ro7eT89WNcXMzSMbNdfZKX8jdReHkP7xopkg52FwING+eycmdxXGLmuuR+Z5LiNTNz9gbyX26yx7HbA4eQ954z3ah/ajp9K1rkMtp+ryWE771Lfr1PLcwodaMzF4tfJuzCS4L6NKX5u1PL6aj0AX7PnRbbQfS7ZemMh2TL/gSz6sNYZr9icwvINLuY+R96k7VIP/EczUqGyCtli8GpGhnToTHkZqTBajazEOoBskbx5Y5mV6sXNW8mK35uYwYdON2J7Ijks130b81YmW7d+rMZ1CTksXWfHxB9nmdchKxOvJpOfmzTmbQJ8iBymacpbiJPDkDyefDjjVeQF7YGjLLd6vchZSLZEeTWLDnkwj5Ye1DpN38mbyBa0fyR71u3S3M7qtrhfvWiakTHeGXvIkj9TnwNT43on2SvkVuC9ZLLmB/X7Pa7tdTtUli3IFsvPaE6vv69CtuI8tm53/2AGLlBZvAfZF8hE8UPIG/gDyBZzd9T13Lmhb8ZZzv+OOz/WeYrsGXtU3ZbOJFuUbz7W8m1vU+SN8uA5RK8hK9FvJFs+nkpWJF1JJnfarIT7GsvRmM6MXB/tRd60N3tk7kImZa8nrw//h44+mH0J5Xtm4xh6OllB+eDG/FXJ5338GThxtHXT9ousXPxD4/35ZC/bNev71ep+8nkaPeumOIbHk5URg+euzWXRYSUfUfffF7S9vhoxb0PtidSYNpzo/t96jPxHPeacXo81X207/nGUb1Oy0c7PWbQF8mCffgBZCXlofd+5Y/8ky70TmWj9Vd3mHtuYNxjS8MyWYhtcHz2RrFC/nPrsKfIerXntvQ45ysXpwANbiPWBdbv/DnkfsAk5bPizyAZNf6rr93Lymuli8vz8hLa3gSWU6QP1WLRyY9o8Rq6X7k/er10DfLjteJdSllXJpN9xjWm/I69rB8OZHkBe372NUXpH9eFFVrhfU18PbUxvJuCCHJ7pKKbp2bfkfcKfGBmmeh8yQfbIxjKn1RgOa3u9TaJ8g0amT29Ma95L7EDWzzy7jfia33Xj99+SjSw/BbyDTKItIHuYvnToczP22Abyeqg5fPmc+tqcvE/5ZI35ChZNMO1Vpx3akfU7r742bkxbnXzu6bFk4uZi4JnDn/XVWKdtB+Brdr3ICuCtyJvDf7JoC93etBBdShnvXU8Al9eD/j6NeU+oB6ZP1feduFlvxkJWhH67XkQsrCfXk4CX0Gh9DMwnL1oPmMEYn0je8C4cep1cT27Nh5bvW8txB3kB2qvWKo0yD27OtiIvmm8lb37+lxxj/CdkpeMh07VN1N/vWreB08iWKCczyg1g3f7/ALyr7XU3DetjcNH5zLrdXVD3jWvJCsf3ky12Vml8ZmNqN3BmaDziGt8L6u+vIlv8NW9S5pNd779BVjLeUsvyMjqQ4Gxs8yuTN/wn0WjNylByv+7vBwEvnsEYhxNjx5APWr9vfb8FmbgcPNvll3T82SijlPFQMjH5ETIh+w7gsHoc2I88n+1Yj7UvqsehBeSQVhu3Hf8SyvVI8obmRHK4px3IG/qPMvIMjytbjG/Veu66mvoQ7OHtra8vMvl/C6O0YgWeRvb0+Hs9z3R9aJnB9cbTyOvZc8nr2VPqNnQ4eT3VrEDditroYqbOBxMoz3PqPrwd2Qvk39SW73X+/clr23dMYwz3qf/3k831zKJJ/EuBt7e9vmo8c+r2+pzRvk8Wbcm9NnmN8HOyUujDdOB8u5TyDdb7YXW//QmZmB9U5u5CJpivpqfPa1tCme9CPpPo6rpNfqGeO55DDm10FSOtydt6TuEb6/Z3M41huOu8FVn0OmnwrIMZ/37IZ1r8mWxg1jwerkFWlh4H7F+PpR8nr5u60EJ8sXoJsiHjQvJ5VG9jlJ5y9Tj1IzJBNdgvOnMOH9rG55H3LQ+p03YnExvPbhz7X1KPWXdrO/bJlpfsJXoBWSdwCY2h91i8t9S09Rgkk6qHNL6Dz5DD6m9a369V9+VDGLnn7My2M47yzSOv324g7zOHh8h6Mo2GGS3GOdi2X0vewzeTZqvU2M+r8x7bQnw71uPMd8l7+uFnP76RvO5cSN6fza/T9yTvHy5ref0Otu/HASeQ122/JnutbtNYbr163D8buLjNmLv+aj0AX7PzVQ+I968XarfXHfnZdLiiZ4LlewqZtBk8/+X9wKfJi/yzqRejXToRN05gnyEvRt9EVu4eVsvxd3K4gMcygwm2xkXLE2oM55EVCnuQFYXHkRVwd5AtDpo3BJuSrXbf3/b6nWTZVxp6vw5Zkfo3RhJWf2Aah1th8QrybcleVr+tFzNHsYSWV13axqdwnZxct7UNyMTCDmTX5H+RPSsOIYcSnPEhEcib4LfUbeM3ZEXL2xnpRj3cAnMtsqXwOjMd6zjK8ubGdv6ZxnEzmj9nMJ77konjtckGCM0WetuQLXLPB9ZtTN+hbivvaXt9TrCsO7JoYvzcetz5F3nOvrMx75b68/r689K242+UY9SbXnKYop+TFUSr1mnrkr0JDqD9Mat3rsf281lOrotque5CXkfcDrx2lPkr1P3+Mjr+rI9GzJeTPaoHz315GtnYZXdGksxb0bGGSY19YxD3ICHyS0YaIQyOuRuQw1HePDi+De9TUxDP4Fkhn6jHkbeOsszjagyL9bxsaR2+n6zg3HkJy8TQeXdNOj5c0hjleG091t9Sj00nk0m+y6hJ2K5t4+MsV/P6di5Z6djsQfEoshfm1fW8dwdZKfmU4c/PULzNxlRzyAZrx5ENum4EXjW0fOtD1tXj+qH1uH9YY/pb6rFyz6HlO7EdkY0MjmRoFAPyOa9fZuTa6CUsOiLFw8jrpUe0XYYlbUNkw4LXsPjwbv8CXtQo6/vIBi2damgwiXLfi2yENHg+2qdYtPfgClN9XhttvTffA++hUcFONpT4E/DyttfXGGVoHi/XAjak8QzPOv0xZA/Aa+ux6WF12WeS192/bbscNc55ZCOzMxnpUdy8r9ueTDafQzammtH6DOAN5GgeV5Cj+AwPgfk68nz8n3oc+gF5fXQBLT0jcbBe6899yGvJC8hHFnyNkZGW1hj6zHY0ehX5GmW9th2Ar+X/RVb8P5JsaXP/oXlrkkmA0+qO/Ja2451AuQYXPSuQXRU3Bu7RmL9yvdC5gLypv4psqXyvOr8zFz+NsmxNto44hJGxMT9dTxqfYmRYmQ9Qh/5ghm5YyBvDz1PH3G1MX61uX1+q8f2cRS+e59GRG4BxlHFQibI5+ayMU+sFxVPJSp/mxdKewD1oqQdRPRl/ipGHSb+BRSsmet3acowyR93fjwPePTRv5XqM+zbZ1fdMspt4G60atyDHW19Q94kfNvcbsmJi3M/LaHF970EO33ZRXadHsOgD70cdDm6aYrkLWTl3M1kxclI95ryl7ot3J1sMnUteODdvBBeptOvDi0zanFvPB78iKy42rK/167a+B1mJ+myy19/bgddTH67apVc9d7yRTKYOWhw/ipHGCJ07XpHn44vrsWS7Oq2z++sYZVhsvZLJ4k+QlSaHMzJ8bPNmeX792en9hqycuBTYt75fk6yoeC8jCY99yJaGnUtCkdetZzGS1L8/2bBoIfksiieRFS4n1O/r9dP9vdSYBkNeXkw+ZPdhZNLgfLpT4bNFjfE1jfU35nGEkXNu54eBZmTokmey6EO71yMTVT8kr7WPAnZtO95lLOvguvuJdTv/Cdka+NlDyz2YPNc/iEWvxWfsu2TkmmdtGr3NyArR5zJyL/07GpV2Xdne6j58A9nwbjsyYfNeagUeHXqeDdkA6uga45/Ja+rhXgO7k42jFpLPhDmM7LH+Kzreapy8f1xI9sZvDlO/Wt2ObiQT9d8kE4K9epZNLctgf5k7NP0RtVzXkQ3tDqOlnl1kD7OF5MgHh5HX3f+g4z0X63n5N3U7OZnGqDJ1/o51HV9fy3cDI40JF3umUIvl+AyNnqJ12pzG+n9rPQa09ZzL9chRAK6px5V303imH3m99GFySO7TyHrH7dterzW239btelDveQB5D/0IRq6H7tV2nH15tR6Ar+Xz1TjYPZGR8YBvrTvwx4YOOHPJiqCXMzQudB9e9QB6OdkC63yyxf0DGvPXBzZimsZHneKyvKZ+R/ev7+9Xv7sn1vcvqSev/zADz75oXHC9iKxc26sxb/hhqHerJ9+FTMNQYTNV1vr7qfUC5yxyGIbb68XPUxlq0TKD8d2LvMnaoTFtlXoS/iZ5kXnx8IXb8vBi8dZRz2KUVuJ13pr1e/o78JoWY96UTHZ8r343/yaTHmsPLbcnmXDr5NBdZNL/8WTLnNuBv9IYkpGZSxq/uB5bFpDJmu+Qw6VcWPfVS+p3fj15E/NEsnKuExUQy1Dul5IVFtfVbemxfSsT+WyCc8lK53+TQ2x+gOwF9QCyQcVpdOTmgTpUR91+nlvj/lTbcU2yLM1n2WzUmL4eOaTDbdREQJ2+Ah1P1AyV70Hk9dCD6/uPkkmcZgOew8ieCdt1IN7hc9nj6zFts8a0HcmK1KsZ6U13KY0W/FNx3GXk+u5RZOOm7RrztiBbkZ7NyFC9d5DJgh3rMq1W+JDXPb+j9oRb2joZPvd27cXIfdteZOKi2dPyL8BLGssuNqzbTJ2Lp7jMg+PTxnU/vgI4g6wgu5a8Fn/Mkj7bUtxPr9/LW1i0IcuW9XhzYd1fTqXRgGQG49uHRZPwg/W8HnktdzHZev0iOlLBOEY51iYbBX67ru8fM8qwneR5+kLy+u+2ejx7aJ3XesX0GGXbrm4fizWyqeeA4+o54M/A29qOdxnLuliDCXL4wIPInqXX1nI+aIr/7yAhvBZ5rv0SOZTyiwf/i6zLeDVZ9zIY7v1RXdx2GuV5GnndfAbZg+I6sv5rMGxmMwHyULJu6f/IRE+nnldI3s8PjqXzR5n/mlrW+8xwXEFjtBWyMfVNZF3q2WTD3k0b89dse10Oxf8A8p74wFqWuXUfO5aRJP12ZLJp67bj7cOr9QB8LX+vxsXZoGXyT8iKnl3qSelf9YLmf1n0GSl9ulEflPGx9WB/Qj0Jf4+8GL2QfNh384Da6dZ1Nb6nkRelg1aD3yHHsR2MwT54XslLmaEL7RrXkWRvn0EcY7ZyI1v//alrFwbjKOfgYuhVZCXKc8heQquSlXY3kzcDx9SLoDWnOZ7BDfwDyZYSC8mb2gvIIQPu1lh2I/Jh9ufRwVb2U7EN1p/PYmT89oVkK9Q1Rlu+uf3N9H5P3gSsRvaE2IyshPlc/f4uBZ5fl9uCrHi6tu11vLR1RSahnk8+THchebM5Y0NYkeNQH1iP71eRyfrH1/1ze3Kc5peT4w9/hp63Ph4q+9pkJe61teyfA/Zofmd0fLgfslJu63pc/TF5jl5Yf/6OTLR9n0YvzRmMbXA9sSpDQ2LW6S+tsX6cHjT+GCX+QeOPQcLzWYxUvL+SrFz8AB0YxmcSZduWfCDsQWTFzO1kS+vBNdTGZI+Vn3cg1uaQT4PrjbuTw2s8aWjZ1cjGVPuSrck3acyb6mHRDiQrIxbW7aBZCb09ee/wDLIiePWp/N/LEPM+jDzzcamNHshruWPJBhRjDqXWYnma19QXkw2Gnk72Lnk5I89p+haN5BMdvqeZYPnfQ/ZoHDyj5l7k81f+Vs97xwLbth1nI97163HlWuBho8zftca/ENh/hmN7Rj2njnqPSPZKP7HG9iE6fu1QY96U7E18LtlA89PNY2JdJshr7fvTSIJ36dU47u9JjpRwPbUX/vD3QDZAW6tua72pnxkq565kQ4rzyHvX19RzXrMyfGOyvuYSpqnhMNlz7zqyHuOcuu3/lPpsD7KxynrkPdn8ttffOMozGFpuMLTqw8kK+r3rsfSrZPK489er5LXOd8lkyPvJa7r5dd79yPuFM1qIa1DvsCL5fKzT6vn3U+R92M31/VNY9Dm6nUj0kQmZm6nPLiLrfK9n0Ya/Lyfr65ab++VpXadtB+Br+Xs1DjRH1p1xt/p+BfIG56v1BLqwHoReTM9a7jbKejxZCdG8oX0Cmby5nKxgfMHwxVAXXuRF6PBF5/rUC23yAYq/AY5ozN+jXnDMaMuoui3dsJRlBuOhH1S3rfu1vY4nUc6VGemtNRjC53AySbAz2VNiMPTBR5imxBSL3sD/hbxReTnwaEbGV70/Qz0JGHmQ4nJxI1/LMrj4fzBZufh3cmisBWRS+giyJX8nLpSWUI6NyV5RP2xsQ2eSFXZ7dSC+5jY3r67vLYa3cTJx/EYyebwQeOEMxNbcxu9KXtjfSibA3kIOZ7jIOM9tr89lKOvryRuYxY7x5EPCTyAvxP9ADofW2TGIl3QcIm/G9iWHEri47gfXtrUf1+36PPJ64q1kYn5v6hjr5I3whcDzxlO+Lr3IYZYuq+eS88lro1/X13vI66VbyWRnp5/fQ2OIq8a095ANKv4G/Hpo+ReSyfIn1/dtPbD8hWTlQ/Nhu4PhPs8CPlqnjfbg7Sm/Pm+cV3cnh9gaHM8X1uNLa71Uxxn/n+v58xtkou4iYL8lLL8aWcGyELh32/GPEt/gvu2lZIXcXkPz78HIs/I+3na8U1juwf58MHD0KPP3IYcovpbs5Xsk2WK49WMvOXzXqWRl8CPrtOYQxSsy9KyYGYrrGrJx2VqNaYscN8lribPr+eBezXldfZHXpduRPQaurOv9tbQ0rNYyluW0es69iaHnLY52DujTi0UbwfyJvN74BtlzaGE9372AoWQUS3g26yTjGJzjDiCvL19OTXiT1wpfpPYAogcNVhrr9X1k44NBgnsO+Ryk6+q+/08az7ekPtepK/t3oxxzGr+vXct1E1m/cWJ9XVaP/TP+jMtGbIPRfPZtzJtH3ifcVtf3x2lplBPGqN8k75UvAt5W97Wb67Fz0KBpbTKhen4ftv8uvFoPwNfy82LRiq21yITFkYx0gzsa+D3ZA2dtctini+uO/PA2Yp5kOQcn4rvWA9Bn6vvmg/xWqSfoX5IXd9+hY8MP1e/iGOAhLP6QxagntJ/X1+CB5YeTQwFtMMOxPrVeADx38B0MXwAwcjPwxHrBsFgX9q6/yETIOcDLGtvR4ES3ct3mfkVe8P13zNtpiGOwLg+r2++DG/OuJhMV8+v7+9HBSohpWCffIXulbE/eDNyHkZuA3wL/Q4vDO7JoJeI9yKFl3k7eVDbHq96KHObw+/UY/Yq2122Na3BcfUo9bg6G1PwxWaGyVWPZlcgWjR+b6WNRI4Z7M9Ja9NdksvjuQ8t04iZlAmVagXy+ywLy3PwORhnSh+xhdBbZa/ZnZDf9VWc63nFsS3chh0B7HdnC8uGMMkRVXe4J1JvQGYyzuc/uRbamO7se2wcJ4mvIhi5fr9vaNYwxXE9XX3X9HkQmpQ4lE8iPrdvXRXU/v62Wb/O24x1nmY6kthgkezN+nrx5vqJub48hr68uBb7VgXg/XNfzJWSDjx0a895HJiCaQ5qsQPa0eSLZs27KWswyUhmxFlkh8mUyQbkJOczQYCiii1h0SNx5XTimkr2hbyRbq29M9hT6RY35+8BOS/jsDjMR4zKU7R31+DMY8q05xNVqZI+T2xh6tmTfX/U7/DH1eX8s2hJ/Dtk78ALgmx2I9b89W+v57dfkMEV3q9PmsvgzPGZqGNl3kq3Adx2a/rzhYzvZCPDv9bzw/9s76zA7iqyN/ypKBJLgBHd3d3dncXd3h8Xd3XV3YXF3X/hwFmdxd3cNSaa+P97T3JrOnWSSzNzqmZz3eeqZud19Z05Vlxw/lUiPQ0326YqcsRaz/T1V7vc22i9FyvjXsBTijRzr0ezn+EgZ/JPtW9czbPR0R3WmLc6X85ChtTAaTI/S476LoqXuQM4x7epkhdKdXYelh0Xp3n+3OVTMt+OpYARmOh/s52Q2X3anOf+6C5IHCt3FDEhZX6TWnCoT3YUsMCNKZds3vV56dgJUa+Uy28PesvMum37SztxnkWNTYexIz6bFbA/92NrCGWi8h6QuWTFf0Ll5PLWMBm+SyOsos8+PwG65xrejtewEeOv4jTrGCNv87gKOt89TGHOzE6bcsQP1SWCf3H0YhT73RYzmyyS1XRCjlwq+U6JQxr3tcyWYOXsPhVfjF0gBMQfNBbSuyEgzFCl3X7MN9qgM9E6JlCEv01x5WxzIaRjpHtanmXKP8wj6NAPDhqMXdXmms88HIAPNbMkztyCv2WHS6LQxfd2RJ9Ct1AyvZyOPjzRf/53IuNOhvbNaGINifvVDaVtOqPPMMraPDUVK143IIOwktO6MFHNN9q5+R8q6hdNnkeGjJxVIe0BNyBofKfEeRRGYq1Dz3roNFexMU2r2agBtMyFP+m2pnwpvNRSJ1mRrZU0qXrtgBP0NSEH1iO33L2Lp9Oo8tw8SipuAxXLTXofG0+0sKM66wcgJYTtgfHsmexQsikTZ036fADlJLITSbB1mND+EvEabkJf/QvZ85RQrtJzicEPbi26geYqlRYHDqQn8letTqR8L23s4I7k2PkqT9QzidYcgwf9YLFow916LolruQ8qVl1HE4jiopsz7KMXjukhp8br1oQm4vJ3oOdnW5zyl61MAhybr9i4qUu8SGSB/RXn8CwVQF+TMcbCN42DEK6UpUrPvM63s35425nMl17pQMxKsbGt40Rz0tWE/i/S/iyDe7mpkdN0xeaYrzWWiCZNzo2FrmebK0WH2VnsnP6B0SxNlHNOJbc84jObpenZE/PEwNeOM9ibg/grMiUKO7A1caPt44ZRTr47NxMio/YCt+QfpAA5sNDdAzY4cQn6lA0RPj0QfJ0N80iHU5NcrkeF1DmpRg9+j6PE259kRj9zb1uWVdm1sxBecWawRFKn/GYpyr4SOaDh9OtzG7WZqRqgihftJlKLOkINDE1bfKRPNPWzM30dOp3ejCI/dbC4MU6sGOYj0yzzWRR2Yu5D+LV23XYqzyebvM7QTnzYCGgcgh/wfkSy4aZ1nTkb6u2+QsW9DdOZ+Ajyac4w7WstOgLeO35C3yU4kXnC22UyLRXCgWgQfYp4E1EL7zq36IdVCn2czhuAXO5COJakxgqU0qfO9SvQVeRA9gZSjl9iG+y5SEk1BcyFhS6Q0uosWiq83iOYtkIffZ8gbs14aj/mRkvHG3GM8gr6sSa3w3ZSl8e5fzBUk/LxHLW/s5EhAOLcdafvLSw95mbxov89CLV9/IfBOhzx0T809pu04HoXx6lGapwrskux33WyPG0KiyGsgjcX7GB8JX/9CBWm7IG+yD6l5hVfOuJaM46UobVtxToyPjE43IuPNV4jZW5F2Nlra/1/b5vdXyDhXV1GDFHl72HPfIuGwQwu+SEF1KBJyfwTuBZap89ykVMjxItm71kPKxbNRBOMcKNrjM5tTB5XnXwNoK+b5xEjxX9D6LcrtP4xRMPnulPZO1kRG2SeoWOHROu9gXVTEee6k7wsig+DVlFKYJs9U2mhjNO5l5+F5NE8DNIXNtYWpjqGh7HW/ue2zvyJF4xGIl/0NKSrftjNkSztHivNltN4LzaPxg63Nz6kZP3qWnj8eKSvetb11qwqM5ea2J85R9CO5NxbyfD0XebB/iZQU7X5WtWH/prA98r8oRWnqhNYV8eG/UkEj/Uj0sdhnuiPF0U9InhuE+PK7SerXIKVfNr6JmlPLFsiRa3OUbmbK5Jk1kGf4BdRkiIbuoyhi7iWa13LtjRR2Z9FCtglk7N6yAvOiGOcLkNx1gY3580jhWxgu+6dzyfbIHdA5vkPufoxEf1OD5NpUOHp6FPq2pL239ezzDMhwuEXRd8RDPQjc3s603AXcbb8fa+thluT+qrb/bJ573FrRl6Wp1bf8FWVyONfoTx1qi7WyOuK3N8xIc1F/7kWUyeF6m+NfIJ3SW+hMPw05Kq+O5Jqi1lNWvZ3tj000dyhI+Y5TyeBMnfz/AYjPv8PW2CMkkZY2ltvbWisi6n9CkX7T56K7I7bsBHjr2A0VCG0C7mnhfrFxL2/PFQWw50ZCwXW5+zCa/d/ODqs/bMMqF3OtrLCGDB+DUS7MpagVm38IpYqZqPR81vRuKCrgADsUCu/LDZACbBbk8f4UChFtl1ovbdiXaWzcf0Rp6rZE3tXllG9FRNSOyCPwBDv0lmgHmtZj2DR5OyFBZGbkHf0ktbo13Wz8vwVWsWuVV7aNwrgsQc3jtwkV522myEh+Hy/Z89ptLKgpHfrSvGjz8UjhVhT5HogUEbsX69fm2o7luZa7Ic+4l5ECsYjGvAWlC+wGzIOEnT8RwzdMmqs2pqc/Uo7fxLDK5ZmQl1aX0vWByAj+bZX3/hb6OzESaPameWTfHEgx/TGKeLqEDsBo2151CzVvwDTP+T9onm6z0cqtHZGgeDZSjn9NTQncpfSzXhqHBZHAfEjucR5OH/tQq1PyCuIrdkFpKnZGjiDn0wEK1Zb6Vey9/VCasZ/oIIq60lnVCykoPkPexkWx9XrpEEfrrKAF5Z+dS01YodrkepEGZEfb/9dBvN0HlFJQZhrH4RbmRumf10LRoYOQ0Wmp3HSX36Wdcf1prmQP1KJtXkdKucKJYjXbV5/K3Y82GosDkPxWpE9aHBkXvrD39pc3fO6GjB/PI1mzSGn1MlI8n2Br6Xnk3LJrBvoWNZr+SeKwgiLSPiVJp5fsoRNhtUUqML4FTfNSS/9UGKu3RXLabrYfPW39XCT5fg8qmjKQmhPFRMjg9wjKkHAcic7C1v6+VDh6upXvsCs6n8/FHCpQ1PUrpbn5f+l7bov/T6InSehZC/FrVyL5ZdvkmUltLr1X/l5VG4oWWg0ZP4potEuT+8W66W5r5lfMCJ6rbyg943fUItoHIieopZDxoAk5hnxEzbBwd+6xTsb7HhvrE1E0fqFnmBudyTdXgM6BKNPIp5gDK815i4HI8XgpEocDbyMxxrkJ8Nbxmy3Emez3bZAgO1vpmWltY/kQWVvfQoqtqXLTPwr97VX6PJ4xBN8gr8FLKeXzrWoDNkVCy37Iq30rajnm/4m8Blv0/m0gnamgORdSABVK9O+T3x8CVs9Nbyv71BMJOrdSS621TJ359S9qhqofgfPagZZCUPkvSXirMQtPJozZysm9JezeY7nHsgHvqg/ywmmyfes4SrnpyZD6BuVJ3iP5fIq9k0JYuA0JmWmaltuAi6mIMiKhazpbA9vZ5zltvDehpsS7BhkN2t2rCNWoeI06dU6QJ26TnWXD7DdYCpWO0lCKkidpbpw8neYpTlZERpBvkVB/IBVVuCPlxIvAtfa5WQQH8iZ/B7grE30DkcA7FDlOPETzdESBOsItNeXLAOQVew+ZC3gmY9sbOfFMiUVrGp0LIaPfAyia43vkkf2czbMnqEhESiv7m0aLdLe+/EkFPMVHln77PD3i9b5FxoUTaMMUPzYPrkLOAj1K9yZBHq7vImeINGVeD+Q08jTilWa1+XJKVcauzv2y082UyMP0PSpWhwoZUF+19fgokgHSfPOLIX6wiVqK0sKQM3vxbnP3Y1TmY/L7uiiKN6351w15Wl+PPMQ/xTIM1NuTG0h3sP1mCiQnbIB4oRtQtNAH1NJnNqGI+K4jmrNtSN8iNk+akAPj2khW+9PmWqFkTBXrm6EzsDLyMqofcS/NlfsLIpn4M+Tc+Kr18wcqEP03En27zd7RkyhNZhOKuJyjtC4mo0LR063sW6ojOJJh60seZ+ujSG84o50th7UhDasiR5xlStf7IH76ZyTD/x0Z9udE9eJ+AjayZyuXCaHeGNvngchx+R5q+pf5k/uzIBmq4MNzpA1PHRzPQTrI5UrPXIwcjOZEzoEr2nzJUsum3jmD+LTLbB/6BPFU16EIwF9pZyfGEdBb7O1LUJObU/3cQVSspndHbdkJ8NY5GrXci7ciRvcRZGFPhYB5kdLtKSTorpWb7lHo56q2Ca1dPlxts7/VDuY3UH7PrAqVOvT/5b2LUicV3ijfFAeUHcSHISHtC5TGbtYq0E5zhcmSKH3PiSg8dJh30hEaUmytD7xgB/JFKP1eoajugVKtHISUYm1++CHD4wmIgf8BFQJe0u5Ni6INfjOG5zTg39QK9c1WzKncY9kO4xJoHlUzC/CwMSMv2B43WSa6uiMB83VqNROORkJZD1R0vQl5eRXK3llt/z27AmM7Tulzb1vDvezzoda36e1zd+Sp1u7RBUig+walQCryBhdjuBlSRFyLlHHfIga6UGRV2kuuTl97IgPG88jpYndqTPdBpWe7I6/Tx2wMnqCitRpsnv+PWt7wZgose2fP02AvX5orF15ERpsmG9MdSWo22TN90Fk3fnJtCsRjnJl7nBOajkS80SHUTw07qa2r3a2vj9rayZrvvA36PRCdl58AK9m1SkWc0lwh15v60TQrIs/jX+1caZM6dUhx2wQ8mFzrnvy+GvJw/RHxPkX09K7I6/Vme24sZNz5FxXnNUprvAsVSZWZnGE72Hi/hs7UzxHveWCd76xjY34BisKcutzHjtiQIfkm5HjRy95TOWp6WxTN8loV5lIL9ws5YSHE822OeNO/0pE3mN6DkJPXz0bDK1i0a2kOTm/n350VmAuFYncd26vWLt2/ztbKYsm17ZGy/XnauZD9aPatGO8tbG/fOpkzHyKjQWHImJCKOXONwjs8GBnXli/d39Xe7d9RitkbkK5qitH8v4VOZWEkrzxHHWdkJJMdiIyrg+x//25n3KG5x29Uxjr5PJuNaxGhdT6q07M/khOK+ZWVL0I8xK3o7CuygyyCokIOJLMsk8ylLojHX4Pm9YMnQPzRv5Bu7kObx3+rAM3jIpn5OjuLpkQ1Eq9EMs7LSH9aKd64o7XsBHjrmA0pj2+rx6ygIlMvIaX/TUghnXoyDWwUnW3U11QAWwaliWmyvg3DFCPF44fAZblpH4k+/sMOgTXtcy8UdnmJ9TVbvsw6tFZaYB/FPgWk/Nnf3sOXxkRM2mA6inf+mdFxljEKY6OUNg8go8AbWK0I+16nOYjrMKT1FJB/M2a7CSnsNskxBkjIHARsbZ/nQorT45HC+gZqdcX62Dv8nVK6rwbSmyqNHkJh0nUN20i4/B1LBWhz8xXgrAbQuZXt82XBrysyVJ5vnwvPoh+RV3KljPSt7OvFyFsrTfUx0Pr/AFLylg0eEyPj7baNpnc4/SiE9lWM3g2QF+91wHilZye08/vZDHQWqSOmQZ5z69u6/Bwpu25ESoVCGFoBCfpLJn9jKlTcM3dh+4LGley8OJ+knkJ5Ly19d0Hk0b577rkzvHeVvK8FkHPIYqh4cxoVMi3yvn6TJK97FRrN+ddTbZ/6DBktF2ZY4/n2WDRUG9Mxnf3cGzk0zZ7cm9DWQlOpPYMZMW3/f4d2iDRuxNjnbjSPiPsZGcimsmtTISP3L1Wbv+00FpMgJdLPyBlph+Ret9JZNwu1mpI569rMgyJIy2dZvfSZfe19vkaGqF+kwPsntWiUI2heI6g3Mu4PpUL6AMTLNwGPU5OFZ7drG5XXMzIQNFHKLFLFhqLYr8ccaVHNmt9IIsntfFgxN62j0Lf0jDsDGaKGiQJHDp7f2zt7H0uV1UY0vISilwp5pe5egXjrrZFD2D5Iud0mNeMyj3sPlF7yPGTM/MHG+Qi7XxVedRIUGfQEciJ6ADmpTFvuU0YaD0WOLIVD120MG73VhQplKkJOv19iqdmT65Mg59aCp7ufNozkHtNadgK8dcxGrdbG0S3c724bz8fIgHE+FcnpPAp9LRSNayEr/UvIovwjstCfT0m5bhtq4eGb/SC2A/UR21i3RUrn3sCEdr8PqhFzD4mnr11fkVKtkyo0akJoZQTjVtDaEymrzkApA+YrPdcNea1cgBR4LyPl43jtTF/30ufVbT78iELKd0zWQQ8yRJc08j3Z7wsDx6Cw9n2pw4RTKxCYrTYXMsx8kKzlQ6ilszuA5sqy94ErMo9xN2o52X9FAtYs5X0SGXQKr++Lkn233ZUQyCtxELX6TcXcHx8ZnKYpPX8/Yv67doT9KKF7epJac3at8MJ8CCmhy8XDs59ndfpRCDsLIOPB5iiK9ESkmHgTKSnGQ0qYY5BBcIuMND+FIlrTM/h0m3dfIr5iHxSR8nKd71dmntn43pDsNWl04lTIkLZQa95hFRoqXFs+E2+3udRkc+wtpATbDxnWlkK87htUSImX7F37Ia/Xx1AK37dsrl2K0uOkufgHYEYpRlHZkqzJaZJr3VDqpCab/9uTKB6Qd+k+dn11ahGk4yNP3kFUSFHRkVoyDy5CEUvlFNYH2r5zvI316YhP3Rs54lXGQN9G4zEn4o9etvl4Gc0zQ2SN2qemyF0Bpesaioxqd6OI2HIdomK9Falqdkf8+8LtTOdeSFE7TK0pZGh6ysb3acQ7TYjO4C+Ak3LPgxK906C0SO8i57RrUPTEjcn6+csZAUVv/AAsnZv24fQpILnzAeAGuzYARbmeSK3W5TTo/DqUCvEWrexj6jxyASaPJWsorUM3PYrunLItxtZ+bmt758p1aFoUOBw5Ce1AHdmZCvE+ozMOydxaC9VMeqreM7mbvZPPrA1BjtZZ6Uvm0ky2X15l+/w+KHLyTzujZmPYNLPZx9b2ku+o8Ww9S/dPQk43X5Ck4Pc2kuOcmwBvHaslB9FApMwvUsfcAGxY5/kpkVLuWxQ2ehKjGY6aqb8TIa+sC4EZUJjlktaf720j2oHmRcErk6oLGWtS78U3kdLqfqSM2BJFeTQh487EuWnuTC05kI+zudKEvCgeo45BBkW2LIOEtcFIcddQjzlk1Nve1u0vyDNl/dxj2c59Lpj87ZDn+2BktPrO3ts2db4zPjVv4IZ5EyW0rkqSygoZDjay9zUU5WT/xZ65AeiXeYwnMjo+RULxW7aHHlred1Do+pN2/y4aFAaOlFRNLZxpZePSOMiYfx2lelRVb9Rq8+xWut4DCfAnFnNqeGNQlYaEmkepec31Q0rHF62ff1j7HrgkI53zokjkDRg27edMdib/brR+AMxh95opITKPdXGmrWtreZiaHUgR/Bk1j8F7SdI9VLHZufedjX/qgd8fKXoXRGko/4mE6Z8Qb1jUnWuiQt7jRntPZPQ+jVrk5VTIGeFz5NV5MDKaNKs9MZpzYwoU8Xk0Cd8PLIeMW02oRsSa1EnZljx/r9FYmYjvjtiAmW3Mj0vmQap4bLJ5/y61lHVFUeaPc9PfRmOQ7rU9ULTs2Uj5/hMy5BQK+lxFswu5sydyfHzB1ueGtjd9hviNNWiBn0M8YLtGgRh9T9v+/iQyYgxDD4pEL+SeW5Hc+VXuuVCiseywVaSAHowUqBOWnh+A9AEf0QGyP6CI8Mfs91MQfzdjcn9V5NTVIRWqyBjzp62Np7GIX7vXbu8H8W+32Bk1YXJ9LOSs8jM1vmAI4k87XTRjea+09zGV/V4ZXVhC36LIIPsSMK9dy57qGTnXPEHztOADqfFqXyO+esrctJbo3s7m+AbJtS7UdMRbIAfMOXPT2pFbdgK8dcyGlG1FLYupqHkr/YckDDp5fim7N6Te/ao3ZEX+imFD//ohRrrwbH8OWDY3vSUae6D0Z5/YIXU/8mJcDnnT3YiMai/YgfAKFahh01kaNQFsOSQUnoo8zZZCip5dkAAwY8E8FN9DnuE7AFe2Az1TIsFuW2qewvMBU2NF7ZBQNiGqe/Q/xBDf0RHX8EiMS18kwF9NTfl7FTXG+wVKhVNpkHBPC8pylOLqRaw+B0pvOBNSCl+OPL1WoiL5qpHy83WkuNsEef8OQimGNmbYlD1TNZi+iVFUz2MYc0wpbUry7CJIsX5A7nEdif4VNehOQ8qUr1Ce5GXs/m7IsDFXblpb0ZfCkNETWA/4Z51npkO1iA60/XcBGhw9SnOl0AIoF36RXrKoMZcqFBdBHqHTlb9fpWZz5UOap7+ZGCnqm5BS6xRqtcDuIbPheAT96YV4uhuN3lcopaaw5woP5RmQp+aWSCF5QPFOK9CX1MP4DhIjVDLvZkGe8r8gZX2bGcZRWo8m5GH5EIrQTx2b9kQ80U/AmSj1XL2I1m3J6AFu+2WrIrtt7i9HSclbhYYUJ02o9sCuyLu+6Nc7SPG4AHb+2tyYFlieGk9YOQVcG4zLuCjV7C3UirMP47DRQHoKXvRUe1eLF2OPDGkP2Hr9DDkOLkHzejxjoSjwdk8la/9vV6PzR+RwsFYLzx1DzYC/Ue733tK4J5/XRzWPfrA5sUtybzlk4NzRPmff70fQt+URj30/kjs3Tu5NjXQ67+Smc1TembX+thZepM65TYm/aqP/HazdADxeurcNcmZ5x9bHkkgOa0IOaD3bkpYGjfV8I6I71xk9Cn3pjqIEm4BzM9NSyDB9kQzzQJ1nUl7td8RzZ+Ex6q0jO3MeR4buXUickW2sd7a1OUnud9+RW3YCvHW8ZodPE7Bocm0m5NH6lt27kDpexyR52avc6jBvhxuTXOSDLYf+7WZMwv9Z/4+mYsIN8ma8B1nr30QpZFJF0rIoemqxtmZuRnbckZJhIWRUmIySErcjNlsbN2Op9OyQu8UYuA8RI/27vaNZk+8F2sEDBBkYm5ByuomaR+VvNte/Roa+J42mX6kZLiqbDmA0xqNQXhyDjAcL2edxbUxOoJbDugmFfzeEAUloGxeYFUVhLYAUDSuglABNyGO0oYXVR6NPMyKPuEvs/FjXmL4mFAGyGA2sEWPrMa29th+1fMJ1a0uh4uoX2RqqZPRJK9/DNcgj8B2bQz+TFKXuCH1DHslfkXhZIkNOXSGypesNoPMQ218+p3kdoeLsq7Typ05/trZ1kubGP8WuXYflr0YKx3Pt+nw5aB3Jfk2OHCaepeYhPmlyv1mdpzrfr8SaQdEVNyDvzd3tWtkrdiyk+H0a2KoN/mdxXh1PzUjwAXIOuh5YrfS/L7Tn3gCOJEn9lHnsxmY4Uef13jE1Y2XljPhIKbS4nWlDkVPCSsBRyEg/W/Jsh1C+tbLfxd46M0qTeYntWwuUzvypUHT5/5CiPttejCK4n0N8Zz+7djmS3XojBeqnSGb4hpKDhe1P7eo5TvM0mBOiGpjfImPSRemZkDw3KRUvvE5zA1g/lKLoJWoGs42RUf+13LQOpw/D1Oa0fnyB5LuTUCTkCkgO/RFYOzfdI9nHYc4J5BB5HpJfv0JpZqeu927bkI5TEc+8PnK0XMv20+9o7ojZFWUyeYUkHWlVG8oiUKRLPgDpKabJSVM79HEPZEj+N3nqf6U6uDepOVfPSsvGkRWAQxpM5wh5XRSt966N540o+mY65EDwCZae0dtovIfcBHjreA0x/r8AR5aud0WK9tMRw/szsEduekeybxO0cL1Il7NH6XpxoG2AhPvFkYf+b1REsV1iQHsjA9NzSAn/GLBubhpTOlHhsrtQ9NKf9vMi5NnUoYw3SZ/2MCZuSRJBCoVKf2FrZnvk1dWEhJ552pGuSVDk25+2VndCEQ9ro1zY+yNh8WIUZfIAYuzfJrNXSjuMRSp49kWGtUupCcr/MCaqSIF2PLX0gqOt4BpJWh+gZlgrwu2HIma6MKrdbe8y7VclDMgJc1dEFmyHhMWj7PpA5H39tq37s4CZGkTbObb+VkmunUwtZcxBSJFSpJUZz+bJ18CWucd2JPu6N6UirMDKSLE7BHlkHk4SEUFFlNAtzKcZkJf420b/SaXneqTPZ6b5FCTMFxEIy9XrU0dpyKniDTuzjkOGmiLquJ89U5yDG9ncqlQ0cqk/ZWXX7LYWPrG99vgW5lbWlErD6c+mtsc22bnVIl9BG0efIYeT4+xM2hhF0/yMDKzn0FyhNTNSaDUxbM2wXAbWa23M7kTpSbZHiv0JqBO1igyTK1o/Fs/97ofTrwH2Pl6iFvlwMTCgCuPexn0t1uVMwGuIryicC19AEVxzlb4zf3GNTLyTnWkPAXvZ5ynsbNsRMzQBVyLl2Pml77b7GULt7O1OcxlzflsvRS25I+mAdago1e+z93EmMj4X++lwi85XoZGknUR89xbIOapw0vvT1sUeuWltRV+KOTcrMsb8lcKYYVP4roqivr5DfNZ+tFP6YpTu9nOb8x8bXR8Aa5TnB+KPnqcFR7CqNHQeX4KihKZCeoKzqGB949GcS+OjtMpNNCjDDKpfWa4pNx7SuTxvtPybxNhY5280/Gy2/eNqxAutijnh09zxoa/tk79S4y2abM9puFGss7XsBHjrWI1aGN/DqDZKYbRImZtxUFqPG2yxvlocXlVuKI3YI0ip0pfmFvDuKL3ED8ARNPfc6GkH2+soRLefHd6X5+5TqX/pO5rSDoii4OL1lFJzZaCv8M683eg6FDFnheL0M5Smbh46UGixzZ3vUcRKz+T62kgJtDa1PPLdkUdLE3BsO9M1GVKQv4EpzinVm0reSaGY6kNNYOxQHuF1+j9MlAxSupwKnG2fJ7ex2Q1T0qDQ3xdJIg0bRG83JHgsjaJS5kUp7WZGgvLEwLEoPPlrlMO6soqjpF+b2x50MBKUe1t/TkFpc75nOPUO2oiG+W3N/YAUWeeiCJTCsPSe3f8SGXYeRcLZl5ScF6re0Dn3FaboKe+lSCn0rs37O2hQHaGRoL+lyJnxUBqlh+1dvQ6slNxv8/QYo9GHmZHCbYjNo+NJ8pxXhc7WvgukqL7b1k8RaT2n3SvOtq7IWPgNVqOnyo3m/N9YKBL5EqT0/ZIk93+V5ladfvRBzkSn2176vu1p/Ro0N2ZCBrxnbI3OhZwPfrW99mCaRzDNVYxp5nGbx+byi6h+0UfIOaJIvfN/wBkoLd5aNs6FPFRZJW76fhB/s6/t9z+gKONZqEBu/3bo76PAf4vzjJojXhPwFIqqa1FJ1gD6BqCop22o1YJYE1N02Xt6h+ZR+JeSRK3QIJ6cxGCT/l+ay5gr2Jr/Fp3J2wF9c8+DUelr6SxYEvGABf9UKcNm8i7mRrLzi9QiqFexe5PYXNsAOXiNn3u/bUW/ivOkm43/G7ZWJk6e6UXzujI9kUPik8hZ5HHaKXrfxvAk22dOoLk+paB9euTce13u8WxFf6ZECvom5LDyJUlkeGdqSGe3awP/37lIBlu5Dh1LIIeWX5Dc2e682kjQXWSfGGzz4QtkrLwByTNbIb3E2Kh27U7IGXBBkhpT3kbjHeQmwFvHbMDfkdA1Xel6ytxMhfLIvwx8lJvmVvRpOtuAbk2u9Ut+nx+lj2hCAtvhKO/8SUgRcbU91x15cN1GxQpTk+Tmts9pwcVPkPKoxXQQ7UhXIQQshhS1WyX37jOm61Kk5HrcDoMOUcwPRZ+9gAx5L2OKROTddCU1b+Q0Aud95JHTrsI/Ekhmo5bT/hNkoEjzkRYMZ4c20tTp+/9sLvUv942acXpxY0zWsc9jodys/4cZEqie0DYzSnf1I/L2Oo1MShhqAuTfkNJwCRvTQhFRCP0nIoXY8sl3+6HaW9s0gM5ZUaqRX5FC7gebH7vaO58YKZxvQNEcryEv7BHmeK5is368ar8Ps76RcvV0dK59jiIdl8hM818GZKQI/jtKE1heu9OiFGRFofPbcp8VLe0RNr+fsnn3NC0Ucu4IDSmAp2FYr/Xivc2MlHh35qZ1NN7XxEjZe4/NrafpAKnejPaJkBL4bmo87ArtdTbQXIE7AJ2191Orl7IdMqz+jKLktqGB6TBbQX9f2/f+RI4S3VEttiWRY8c/bBy/Qorpn5FC7tYq9aMV/exp/boYKTZfRxFFU7S0DjpKS/ae5ZAjy/rJvSdRlMr6iO/9GvHj65fPlHakr5B7FrE10JS0Q0praBMU8bu0fZ7Jzo5/NHhMx0JyzA0oWv8KJJsdj6KR90L83hJIvnwIyZffISVwh5QjSu8iUKtpVpn+JPOpp63jD+09FVEp99NC6smqr3VqssRZSJm9Xpl2ZJi6CPHlfZP7k9n3dmgn2tK5MVbpXiHjjIOU3oOp1QerzNypNx/QGVg4kQ5BOol5yn205/tSEX0XI2GAHJln25C+rZGcOY19no/m0SoFr1bwmY8gp6GsfIXt628h2WtW5Kx1kJ1djyAd13fIOeg/th6Px1Ike2uDd5CbAG8dp9Fc2T+HbSbrJNdaKpJ9UHFIdYRGLQ3SIUjAXYXmCq2DEZNfpChqQh7J/ez+PMiz5cLcfRlOH+sVXLwPCajP5GImkHf9k9Ty4K+KolGWRx74lyVjfnLucRyJfk1vB12hSHwDGUkG2v2u1JjSKVCIbMPyfyJF6DLUcp0/aWPf4RTSrezvJMiwcWNybezk9yKyaBpb59chJnZ1pMy/OQPNYQQ/y4XMV0IGhlMzj/U41FK3DUGKhs+QAHkyUt5NgxRev5ApdRJSzN2P0nlsae/5T+TVt3rp/OuX/F5pD8UW+roDLaQhKp11cwM3FWdcbrqNpqOQ13txDvwbeV+WjTeLI2P0V7aGzyezYgLVUJiVkhCDUlK+hxSHjwEL5x7nkehTizWDqCmRBqKohG+oCaqVU1iU1nh/lFpsM/s5TnJvBuTc8ILNwYZ5abZBH6dGSvmXkZL+35RSdbTVPCiN55rIMP7v5FpfFN3xiY3jirnHp04f/oWyBSxYur4XMtTsZvPjYBvTo3PTPIr97I347Afs3HuOUuR1R21IlnuJWvTfetbHJe3zNtR4lH9loO8llEpsfyQvv2O0HJI8s5idY48jvulx5OBW7KcN4UNQBoTi7H3M6PgYOTf9bOM41O7/mqztJkopWXO38p7VmjGs4rlVph8pSz8EVrDPE9q7OAwzZlAnvWNVGzUZZ2pkuNyfWsaHwsFuJWpRAB+gyLQZaFDUI6V0enXuH2Rr/JTWzrUqNNsbb0W6mU+QQ9txyDmq0Fn0R9Eju1VhntjvfZGhYz4UBVWp+Z6M3eyI77+QxDHO5tM0SFZ7BUV430xmpy5q0Tb7lK6PjXQqn9tcuQ4Z65tIDKzeRnP8cxPgrdotOSyXsk1laqRgDrY4L06fReGpiyEm+U5j4irvWVnus7VTkdX4TeStvlDyTD+UEmFJFA7Yx65PhrzGf6VBRcpHs6+pgm4cFD20fi5akOB7VXLtWaQ0LKIaFkceoutRkWK1I5pLpc8LI0XiW0hoPI3m+W57oHRpg4E1M9A7Dsp5/DwSvK5GXpiV9sIaxb52SebVHogZ3a70TJGS7Ed7J4ORQP2XsS13P+r0q6y8zkqjzecmOy/uQvluN0FFdR9DgkARCt5k76LhNNu7PggpMrew/ehQal6iVwLL5H6/bTE37MxqArZu4bnuNDcA/g2YPyPdhTJidVuL59vvhRfg8si7tD+JIQp5Ba+FvL4azofQXKFQeFL/iZTA/wSmTZ6d0M6GX+lExV6RMPcYih4t6jNUbt9M6UIpG1+lpmz8AynB9kyeDUghcDwwUXEtM/2pp/UyyAv+JGSEniF5ridKU3ak9W//Nvq/09ia3BlFGI9NUicSed9/jDzz0zQ2s5DZuWA4fZobKU1eKmhGNW0+tfGtfEHpkez3ePb+bs1NS1u9Rzu/zkuuPYt42wH2eVbktDYpNVmuXZWqyfw6HvEYyyX3prB18hCJstHW9IvUjDdb2/VGRQZ1RV7iN1OTjRdFqQG7ouifaVA6nCVRmvRtkVHz0EbQOJL9KfQbiwHT56anjfo0wPaqk6jVX/yXvaup7HMPe6ZD8bPIwP8qdaJbrX9X2hq5AclqTyPFfTZ+A/HSR9k5exEVqq84HJq7ln72tbN8PqQH/BU5BG6LIqi3tf6tac/nqkFX7KnbIx1G4Vj9GtJt1a1Z3WDaZint9ZOiesFfIKePI0jquFKLhD0NuDsj/alB7GDED2+SXFvA1tze1M7QselADmgdoWUnwFvHaLZIm1Du4z1sMV5pG/faxiA8RvPok3fs8GxIIenR6NsKiAEdJv0LYuZvtPvPAAeSKFrqPH87YrZHSwhucP+H6yHSzv+7a0JDV+S9MY9dmwUpcvdJnl8XCdAzNJrW0exnqgDtaf24GSmIP8OMBUj4eQR4MvN8mBx5ZRU53HfJPYbt9T7s89YoF/HXNv7LJvcGoALaB9reN5tdr6TiMaG7UBhnN7ghBeFtSDnxIjLqj4UMJb2R0LwPYv4bXu+itD73RYakje3zrCgV2s92/p1AgwpWtmN/+9r5fJV9rhtRZ3vB7FSkRgOKsLmamtF0MqSAu8zOhS+RsHYyzZXUE9HgnMrUhLReyGD5BFKGLmF0voSUXIHmqTEnK8/JqrYR7S1IObQ8cBUyhIbWfC9TX9LCtH/Vc0IC82EoQnCI7QVTJd/rln6/In04zfrwhZ3hPyGj4Y4kxWCRkXPh5PNovRdqRXRfRx7RH6AUHzchj911UJqaF4CN6o0bFTxXkRL9NVSbYwrkSfotcsL5q9ZCW4xhO9A+0vQgQ0dRn6dy76Mlmu3nkpSKfKPzbtLkXb4EnJ7cXwUZlRtSsyGZMxNRU3QV86dQ6t5la7d3+h37febSmdHQOYdks31tTTQho0C2ekCj2IfUgeVdxA/1qzeeVVvTw5tXSL78H3CCXVvI3tHmSZ/nR7L19rlpHsn+nYWMM+X3szRyuit0B/2R8aYJOLcCdE+CspkUzh3ZeYVW0n0asAbNnXvHt/3ybtu7fkW8xg3FHMxEa1rL6VekX9nU5sbvtp9OVIExLcbtTGDK5PpyiL/4Dhnrd6A5rzaAJBtI5j5MhHSdX1OLVr0X8X/Tp+/DWxuPfW4CvHWMRs1zr0ifdB8SxAvP0aI451nAxsYIjUNFlD0j6Nt6SAA7wD4PkzcSefU+bc/dZQzQMBuoHWab5e5TC/0shJqW0plkYyRQuPMGpWvjIOXpxfZ5cmMiPqKDpu2iuXJ4QmpFEpuQUfBM+z17oWZkRJsLKUkXHd7c6QwNGQwPRQqlb5FRevrkvjMhIz+m5Rpa66G0K3/YvN+a5mnpcnrEpamcrkKK9QWT+yshg15lUoWNZP/+SXMPr/OBr0vP9ESpHNdBHsD3ISEim7BDTRg7GKXXWphatG8XZAT8FDlXHG+/NyGhrX9GugvF3ClIIbhQMc+QkPt3aqlK5kYeypXfX5P30WrejqRuWNX7iGo5vQ/MXbo+E4oOHALsV7W+JPNtQaQUOJaacfMV5FD1A0pbsSZtXMsGKab+g+SB92xv3w+l6rnb1u7z1NJQ3UhF68KV+lWcCxsiB5vb7Pw6hA5UWB1TrnTmZvvMn0gBv0lL7wcZYJ9GxoeFUcRUw+uuUpOhh3GKQobPoth9sXfmlNF601x+6YoMAqfa2v4NRe6NlTxTGYP2cPr1LJLpFytdD1gkVkdq9l4etb24C+JZ78dq1aLIj51tL1sgN70j2bfLkQNM1/L5herNpVkrJrI1dHg70pPN4bUBY72o7U1votS2qSzUBelj1kC10PZJzvLcmR3usbk/k31eHPFD61OrL7RgRvrWRQaP71DGlYNKe+YONm+/QOnG1ijP9So0JCveinjLkxBfvDkdQOfbkVt2Arx1rEYtfdJzJHlqkaKnchvLSPQrVc6+DJzTwnN7IYH0A+Q9OHcj6BvNvvXLTUMdmmZDHscBeY01IQNGcagWKeouscPgdmrhrh0mf3wLfS8rsmcBjqbmtXZxLtpaoLfDrutR7O+iKD/v+0gBfAx1BNEG0lMI7B02DQvNPbW6IGXeR0iJeDOwRun5dlfiAbtY2xQYFxlR03V5he31K5W+ty8VrL0wgr6uhJwtPkUpGqZC0U3fIoP5Nshb9mV7J0X9oXeAwypA/zi2999M8wKzmyKB7G/J2dETpXBoop0Kz44E3b1RxMYV1Dymr0I1zaZInnsORfF1GAUA8qzLkkq1HfvUHSmG/kfNCNKj9Mz1KOpuwkbTV6IjLWK+eXL9VqSEnM4+L2NreWNqBalfsH62acQginzbE0Xg/4gMrYXn5QCUqmZZpKhYPvf7HoX+bYailj4ho+JnFOjexN77arlpaed+jmNnwn3W33uRnNGt9NyWtia+sff5XbGXlZ9tR1q7IoPmd0iBfjE156iNkXd4QyJ/WknvkyjF0ISl6+Og+pfX2ln8PhalbPcrZ5BN9s71bfxXS+5ND/wD8X630AGNnchr/xOUSvz3tA8oyuZZOqbj0c62rtP+dKvHN6GIu9do4ywR1AyRfUs0VG6et0FfZ0WGg+9szhxInYg6qEYENXK4exFlQyje0/NIf1SkwpwUGfY3zUhnLyR7PoVSgz9O4rSMMhmdZGv4E2Q0q4wxhOa857u2Jq+mFp3b6dZCVVp2Arx1vIaUzlPYBv62bejHUApJ7witvLnYpn8dEsq/IhGGk2cmRMLvTyRpMqrSqCl550CeT48hi/5ZxlyPn5m+HshL8Uc7jF5EnkFF+oJUcdrNDrcX7WDbM/f4tuE4lNOCLIeMBR1WOd/Rms3Fmexnmm6iJ1IE32D7wCs5mTyj6UYyKwrboA+p8WYgMiB8b4zpOVh6gwbQsZwxmt+iFCR/otD0h5CH+tqoOPx/UKHufrnHrg36vAZSQnxn5/ZlNgY/IM/xb+ysOBV5lVcmBSWK/CnqIl2MKUyR88RFWJF4aqllZkBGnpMz0lwIsrcBD9jvhffipsk5PSsSLI/IPc4j0adi/exCJxPQULTWUGCu0vVCIC1qnFUi7a/tW8/Y7xOjiN3Tknf1gq37QolxW7LmZ2wHerrYnC7qM31oe2mv8nPpnKpyS2jtgnLOfw/8Pblf6T4gx6inbC7MmPapszVqBZx3R17ig5C8NkPpuamR/HEiSQRqBnrnQobWX5CH9XEo7cwJyTNZ3xXyqr/XztSXkLGjb+mZSYGtEA/RBDxIKXqlag1FVb5OzcC9MIpK+QXxfZ8jA36H4LuTPb8vUvoWmVDORrL/Fkj5/ikdsG6ezbEP7ExZsXSvS9L/fijC+ZvyPG1DWt5F2Rh6Jdcqo1gfzb51obmstqqdH98ig/imGM9dtYYMdcfb79shPmfR5P6ytqa3zERfOq6T217/i/EUN9K8dvasSCbdO/e4Dqc/cyH93EvALHat0vxQR27ZCfDWcRvyFJobFRX9DXnlbkkHV3Aho8y6KKVDkzE5w4QRA5Pbz8oIP9SEy7Ht8Poe+C8Kkf4KGaPOxrwlctBu82ZKFF3yGxKqrgBmLj1X9o7rMOmpRubQonnKgU7B9FW5UVNerYIEzN+R0eAk5DkyTvLsxMCuyGPtG2Oq2lzRNbw5YZ+Xt71oio7OENn6Tw2ziyKFwA+2Ry3dABr2RMaLIUihsykyVlyKPCzfQdEQhdC7mn2vo499DyTIPIXSvw1GxvCFKSlVk+9Uos/Ga9yMBJxXkUHtm/QcpmYImQE5KpxfAboPQ8LubMADKH3DJHavJ4py+h7zqq4SP9HSPEBpEJ6gVti4EnOkjfq5lK37W20epf3uiYw235BZ6UVNQbWF7WPbIg/OU4C17d6KyHCyCjWj0xnIMDVNe84322vSlMpPI+VP7/b4fw0c9+7I4D2EDuREhCJOvrV1O0luetqpj+W1Og+qb/YdSjezH8NRwDdyH2NYPmgdFHE5xHiOw7CCznY/t+FmEuTM8bjtj7eh9GjlNFWzIofOz5Fxu7IyDYqaHozSuc+D+L4Xk/1zHaT0nTM3rS3Q32y+2890ziyHDLU/2h7chPiP1XPTPip9tbaX9eMNFHkzVZ1nt7G9rk1rCydn7kAUWdaEeLddS891GF1FvbmUXCuv7b1tf/razsA1GkHbSPbjUlRXegXb80+hloZ4HOSU9xkwQUYaCx3EjrY2t0I6sC+RQfV0LLVtlRtmKDX6f7A+VNKY11ladgK8dfyGCkqvghRvQ5HX6Li56RoJ+ouDuA9JKgyUQmZXlDKmCP8bLze9rezLJcgTZFX73B/V7DgTGUnuSpm7BtE2c51rXyMFSBNSJG5ePqyQd83KVKCI3Cj0eSvk9TRCgase0+StXd/NF7a2T0NRHt8Z03QEKr6e7gWzUauXcXmD6PtLqEeeYz8AG3aGuYIUeluXxnhLZBxrd4HHzqxlUVTlUOBOpGDsZffnRwUst7IzoMPtPdaP3khZdy5J5ABKY3Qs8jL9zMZhgeR+ZRQtDJtOch3kSNGEPC53orm3Y0+UXmYwsEwF6O+PIkl/MZpXSO6tZHtQ5VOVUHMIWRNFVj+bm6bR7Mec1o+Fy3uOzalfkEfm1vZsL2QgeR+4yp7Lvg8D4yHHnGeQED0+NePltnZmzWuf+wEX2H7XECUwtZTKz9tee7WNZ/axqzcvWjl3+qG0MU1V2GNa2y+kyPrU3sG45fudsdn8W45a+q4XkVNeJeoRMWzq2L1R6tjvUQrurCntSmdvF5Q+bF/k3PIbMgJPU3quO+Kvqh5pMwUyajRZX/6XrmfjI76gAY5EI0l3l9LPTZCT6bMo+mMrEuO4vYul6UApHUfQ/3UR7zcI6Z0OtjNlGeSU+hVwVzuNeV+UKeQD20sG2/x5iyT6B8lvHW5vRfWbp04+B5pnoVgHycq/AzdkprXgc3pQi7afG/HU3yL90pLJ81vY3Di2wXTWM4j1RzL9scm19VCk3/cou8fBLX2/ag05Qv6JspN0uHnfUVp2Arx1noZyVu8FnJeblpGgudj0J0N5MPejuadKAOZDIetfGmN3UnEvN/0t9GlClP7mTIb1lOgO7GZMRpt6oYyApnGNybkbKw6NBID1UOHcNY3hHIKiGVZERrSuqMjdD2RO6zYKfV7W5kuP3LR4G+bdbGBMdhqKPBmqhTEEhfpuRcmLC6Vi+oR2Sh2FjAWX0DxfclGr40HgH3W+U8l9qIX+FUaoo22PmoKS0qLB9PQ3Rv4lpFC8lop6VY5i/04yweV2YNnyGNt8+4edbZ8hBUwl05yW5wktKLeQ0vop4MFMdNYT0BZDUTY/G81nI6Xvl0jALKKFKu2hiQxir1KrZ3gsFXdkqfdujA96ABlmtkrnVXJ/LeRVPtT4j5+oRab1T5/P3ZCyaiiwTamfSyDF1pEoDeiWth8c2Ej6ER89OYoe+JAWiq9nHsNCFjiKUmq8Fp5fPNceMwp9K+Z1D3sHTcAxuelq8BhMgpTbT1r/b8GMmen7z0hfOXXsBdRSx55N3uLZZaN2X2AB5Oz0MzIE7glMUO/8q1qjuYFpdlT8+9DiHLbrU6AUaa/mpreFPhTe+nPZ3v82MsZ/aO0u4G8j6n9HajTnXWdFOo6fE36kCRkTDqONU9cne+iVSKG+U0LHHsgpoQnpL6ZMvldpnq7Ux2WTvXEtjM+xe0Xq4amtr+tTSyuYe++8ANgj+bwySo1ZZMq5AslA3wH3N4imggdbCukVpi7dvxBF9k1d2o/Gtvn0ER3AmavUp8uBe3PT0ZlbdgK8da6GhLPKeOmOBN032yY/TA0buz828lK7CXguN70j6EtvFGVTeIN2LzE7XZBH0T00TmgfiAoyn2Ofe5EUYrZrEyKj32dISXI+qsPzJRVIc9PKfqbjPDtS9CyUix5vzd5NoZTpSi0VxbjpPft9AWQg+RMpf6dJ7u1mjF+7GBCRErQJCcHlkPtTUUqAZkUv7XN/5B3e0Oi5kexbwcROhYyZB1ATPEOj9qJ6dCGD3eG29/xk72HyHPS0Yb+2Ql5lx5SuDzPWSEC7x57/Dlg5N/3D6VdLyq2P7ffTbA1N32C60roXExq/sCSWjgdFROyHjAUfIX7jJExBnGv+j0I/C0/rD5DR4wRkEKg835e8o9ORp/gmyb16xrZxkOfpxUhBtCkwWXkeZuxPN1vP4yAPzfeAiexaV5tzN9t6+BIptB4ZXp/bmd6uSMl4NbWi67mLF89BLc3fkjZWm7W0HpHyv7JrlRqfMxNKPTqtfe6ZPHOg7fN/R1GnXXK/h3Ycj3KkyAzA/sn+1TDntdbQSnMZYhGkiG/C6qI1mJ7pkIGmJ1ZrM51H9nlllJLoT1R/YWUqmCKnPL8ZjjOdrYlTUOqiNe1aFfb7tZBT1yzJtZuQvDK7fZ4KOZm+hqJCLwPmzk17O45Jf5QObRtgI2C2dvxfUyPZ5cg662A+ain1mxAfmn3OjETfinNjd2p1Vs5DDkdppM18yBBSiagt4yluRs6WW5XuHYxk+NeR7LwbDa5DbTQ0IZ3crraXzo452dBcbkj3/hnoYGlM7V2MnZuOztwKJYrDMcYhhNA1xjg0hLAmEiJ3QoaOwXZ/EeRF8ViM8XW7NjHQFGP8KoTQLcY4JBf99RBCCEiQvx8x3MsntPeIMf5pv9+IhPvVYow/NJC+XjHG30MIp6IQ51OAy2KMv9r9rogx2g3l+xyC6vGsFmNsahSdI4MQwjiogPrD9rlLjLEphDAu8kg5J8Z4SgghRNtw098djUUI4UI0x8ZHyukv7XoASN7R5qhY4TL2uSvKyT92jPHf7UTbBCjqbAukcHkZOCDGeG8IYUGUZmlBpKReEKU8mNfaWzHGmdqDrpHF8OZ3COEqpLhbPsb4aUMJGw7s/c6BiqtvjAxnxwI3xxh/zEnbyMLm8mfIY+5wO6+6lPfQ9AwLIYyNPE43QuviqwaT3WpY/0LRHzurD0eprvoCZ8QY924QLd1ijEOSfX8/VDdoGiSIfY4UbxfFGJ8NIfRH51rPGOO3jaCxrRFC6AvMiAT8jZGC6EzgnhjjZzlpawnFnhRCmAZ5yh6JosJ/SXjBSVGq35mQwu7aGOOb9v2uMcah2TrQAkIIPWOMg0IIKyLl6WExxstKz6yHIkOeBh6PMX6Qsz8hhO4Fn50TNo+PBLZH0Z9bI4em3WKMn9d5vhuSFf4GrBJjvKeB5I4UQgjvotqR3yEj8bMoZcwdyJh3ANord40xPp6LzhwIIfRC6ZR2RobYE1HKo6Yq8OXlszqEsC3wYYzx/kat2xDCOmhcBiCl57iIpxiCUob9ipw8fkKy5GyIPwbYMcZ4UXvTOCoIIayA9vjJkCL39PI5HELYHzkQXt0oPqI1CCHcjOSD51BU+OVoDo8TY9yv9OwCiJddAr2rO4G/V01nMTpotBwdQpgRpSI9OsZ4sskMIeGhB6Bai58h5783gJ1jjC83isa2gPXrDDR/PkKGv/tRvw5Ee+Z0heycGyGEqdFaGIgMN48n9/oiY/jvOeZ+CKEnkuX3RPvjkyi96jcoEu670vNdkBoi+znkqB7caOMY4xFCuBcxojvEGD8JIUyOhLfD7ZGhyEJ+UUfZSE3BeyPyfjoKuKJg9EMIc6Gw7+dijJs3iJ5CKVIotnZC3oyTIYXPRTHGm0rfGQd5G7zTSMPSyCKEcAZSXl0AnBJjfC+5dyfyYFkpNZol96eNMb7bUILHYJiwfgESfMZB6+BI4N16BrVk3ra7gbb0f6dHyvNNkGf7zcij/WK0Znojb8APkRBxJ/BoOvdyoNSHbshz+ReUoudlW/sXALfGGO/OSGqLCCGMhdIN7YFy4b8ELFdmrquMEMJ2KEXE1jHG+0fwbFeUzuE9+9yvoxip6ii3Nkfea8s0SLFVnGeFQWAetB7vQ+fvIKQ02RKludk3xnhj6W90GAN+WWFoa2VZpABeFCmEL0Npo37JQ+XwEUIolA6bxRhfSK7PgFKfzJc8/g1SUlwONYN+DiRzbDmkUOyP5tf4yJNzXHQ2/AEcFWM8IRetHQV2RhXrcyMgAifHGP9u95utTeMfjkFORfNVVRlniqLZkBPCpPb7nIhvmBzx3P2Rkus7YOMY430daS9qC5iTzDUoMnKhwnmsKshsWP0Zpaj+AkXpvY6UjZMib/F+KItDLyQ/j4N4vb4ouuv9DGTXReJYsTWqTdkTpUeeHsnIJwIXxhh/NX5oYXvmmRjjz/UcXnIhhLANihSbBEvVCbwSY9ze7jeTM0MIa6GIuqdjjLs2nOB2RnvtWSGE/mW9gxllnkRn7Boxxo/sevcY4+AQQh/gCZRGuyuaa/+KMe7U1vSNKkoy2mIokmZOZGD6AHihONdCCNOh1IxLoijdvmitHxdjPLZKjiwhhDkQz90FRcf9L+GZsp9rps9aGzkjLwg8BuweY3wxJ12OjgU32jjGaNhGejMwJMa4ol27Fh1SVyKviUORULxo7o2/tQghFIW+D0IH7f+AWxGDvQ4KoZ6tnjdhO9JUFoAnRl5C6xiNjwDnxhifaRRNbYEQwurIs3oR5J17CXCWCQDbIsZtGmP++6FCefMAqyGheZaqCARjAiyiYF5kiF0H+D/kVfRo6nFXZ762O+NX538uihSM6yOFS0+0L12KGOyvY4y/NYq+ESExcm2APIsWRIqwD5CX964oB3U0ITo7zS3BBLQtUZqtnTOTM1IIIRyKomYWiTF+1NI4m1fX2MBVyLB/TYNJbRVGNE9S4bFRCpYQwmbIiLpdjPEKu3YBSn2wVYzxrURonB/tMfMhgfKeKs/9Asl6HoiMM4sjpd2dyPPyfVvHEyGB9ADk3T95rFAUHTQzeuyDlF4zF4ZYU14cg97PP1Fa1jWQQf81FBX4fR7KmyOE8C9Ui6pw9vgJ7bGfoCjr+ZHS8X1Uu+Ym+15lFI9VgzlqFXXNxkMpDA+LMT5Vem4AUlbHGOOHDSd0FJAYlsdGxoneKNKgOzLmrIUUSBvGGL/JRmgDUVJcFpFWy8YYX8tBC+Q1CNdDCGFp5Cg0P6oHcQeqDTHI9tFJkSJ3QqSg7ouicr6okiIy2fd7oejpu4FDYozvhxDOQ0rUiJTWB8UYb0u/l43wEko8Tj9kiNmCmtFsy5R2lNKqyKzRFxgaY/w9C/GjgTqOOe1+jhn/vBCKTHqxdG87VI/kBlTT6ekY4yC7NzviHy6MMV4YQjgZ1eSdPlbAOTNZC+OjyNLt0dwZhGTL7iht77XAJTHGT+x7i6J0v78Db0dzPKrCGgkhdEf6u4LPvhqt8x1ijG9UzLAUUK2sTZHuqw+aQxcUY+1wDBexAjnavHnL2VDu0aLY411ICD4guX8SMnpMlZvWOrQX+TCL/OWTkhSSRgqkf6Iihb8g49N9wNoNprMfSV7k0r15kHfu+0hBcgwVLYY9nP71QIabp5Dh5mmUQmN2lIrlRpR3uCia+AsyCG6Qm/YxocEw+ay7Is/kLVBh7UG2ThahAnVhSOpDoIia9VDu6k+trdVS3zLSXOxFE6GaVPcCGyIj5de2NmZIn616gw5bo+0Y22N6teLZriiF18656W6DfjdsXtl+/yoSep9EKf/WQim16j0/L0onc2PucRqZsUSei/+HvEu/MV7pTzuvd6NWl6o7Siv2t0a/i1F4b01IyQUwM7UiwtsCvZNn97frs+amO6FpfPtZtyYDMprtj1JrNiEl5byNoq8jNhQlsBeqx7EvKhA8BCnnJrdn+qB0vr9RqmdQtVbs+8M7uwq+AUUafQPcZrxGJfiJVvazqMMwLlKyrgBM0NLaqPP9fsgg8WwDaE1r6/RA8lC611Sy/gVytPnJ1sPVNsbleh6VnTPJPD8EKaQXsc9FZNBxSA743fbLh1C66+y0l+ivJzvPipy4ipplx2PF4e1+N6weSZXfUUt9Ll0bIS/bhv//VBvT+e3zBKX7R1OrU3Iyks9WAR6282FSe243m1eL5B7T0ly6FumETkTRubMih5W/21pvQjqLFmsh5ZpP1PjS/vXuoUj734Drc4/3cPrQFcnFlxitbyMHwX65afNW7ZadAG/ecrXkAJsDGTI+Q/k71wf62r2JkEHh+dz0jqAP+yIF0uco3+1JwMDkudnsYJ69QXQVB+t8yBj2EwrlPgKY0+51L31nTWQ0ex+Fri+de3xHpq/2+6TG0L2N0k48YgzQWygNw4HA0vUYDm/t8m5SQbm7rYHpSs9MgVJJfY0MIqcDE+WmvU5fJkUpu/5rc+rxKq4RY0RfpVZgfTyk8N0VU1Ig49hUuWntrA1F8TWhKJBCmKkrZCFP2ldQHYfstBtNhTJuFps3A3PSMxw6Z0eKkg9svD+0uT+F3e9Wev4aOxsmz017K/pWnOGnGF+xrX2eHim3b7M+X1JvbrU033I3OwduMdrfRPXBfgeOr9P3vVAdkMVz092K99SldH1epHz6wXiR7o2mrSM2pOhcFEVb/YAMGociQ/j3wBG5aaxDc7FfTomi3f6HnIT2t7M2dQIpjKwh+V7B/8yUuy8j0edi3vdAtf4G2ZouatHNQyuMa3b+zdjAd7QhknOeQY4425TeT1bjDXVkRGRgOtvG9yukqJ639ExlnVuQMfJyZHQaz65dZGfxQPt8MFLCf4nxTbkbNfl+gO1H11tfiloqxXMrI8eRX6lFtPfLTX8b9H9lFN31CopsObQRa9X+97j2c6CN6Y4ojXBxfxHbY5uS9gaK8AAZhI+xs3fiCoxlsV8ug+SxbajjWIOMmZdbf65K9yMqwtMhmf0xZFjaEelUZk/ur4n0ef+uwtgPpx9jIWPfvSjK9/li3nnzVq9lJ8Cbt6o05HE5funaVsjgsLV9row3VHIIL0LNQ+gklLbkQ2T8OCADXQWj2RWlnCi87F9C3lq3kEQzkHjFoVDvvY0BHS/3GI9Mn2luvCnSrHyEckJfV+pzJb2QO1tL1si6xhh9a8zRY7a2+9j9bshT/ip7ZhivtkbMIfs5A0pteDKwPDB1aY3MjgyD3wAf5R7jUh/GQQbwS6h5+N2NFBQT2+fuSLjZtSpCQGdrwMRIIfE2ibccZryhucJrZxQdWIloAporIx5FufQbGhk6Avp6Y0aZ5NpywD+Qh34TSptWKOmKsR7HnvkYGDt3P1rZ13GB94AzKUUgIg/NM6y/G+emdWTmFnJiORZ52T9q+2wRnVDsW/2B8xEf1fDzYDT6mPIhXVEK0OWLz7np6ygNKUpXR4rSP5BC9NbcdI2A5vuNf3kQpX1uMl7nAIZjkEFR4U2oFlj2frSyr8VaPg8p2o+293UeMsK+i5xcpsnNZyRnwJTIuPQBktc+t/f1KEqb+VffyCAjIAPWT8hAUM94Mz3i75qQIn0vEkV2VZvtg4eielUg/uhr5Ow4ll3bEHgRcyqsQkvm+LmIl/tn6X7ZKWRvO69/QOnQN8zdh1Hoc2FUXgvJzh8gfup1m3eH0o6RjohHLmjoihz9vkbRxTejNLADkufnQ5E2y5IYCJDB6UPgtNxjWurftShyesqiv8m9v3hWFIXTBOyfm+Y6fVgGZWV5xvb6QfaOXrb9/1SU4vQXzNmoyg3xGnsB5+WmxVu1W3YCvHnL0ZClfnMU+bEddZQoyEvtJeCe3PSOoC9XIcXotPa5P8qZeScSCJ5BRfMaRU8hoJyDvB3WRcrBaVAoehMj8Oqmk0SiIIXJvcZEv2EHs3u8NmbsCwZ0RqSUfhQpL7a1OfgAJS8c5B1VpENpmOdgIiTMg4ThwchjtAkpYrZgWEXxyqgYcvaxLtF1D3CH/V5EfKyR7Avz2L56YG5aO3MDNkCKxm+R8qpvnWdWtH3p37npTWgq1u0Rdn6sXbo/PcqjX0TDNlQhh6JlXqSk1LK9Ywub/00ojdhmqFD8ZPYOPsc89amgAp1hozXGRYqH8+1zd5oL+f1sn7opN+2j0NdCIZb2J/19deQlu09V39fIvEtvozyOEyKHroWACXPTU4e+Yr/cFimptkz4iQ9QdFDh1LUlpdTDyAh9OPBk7r6MQt/HRnzcITT3CJ8JeWE3IQXlulTA4xpFLT6Opd9CDjonI0X7dygSZM6M9M2Iogp+MB5tf+pEnSO+7l0b33uRLF35/YaaQX5OO7eKSOQeKPLghfL6yEhrwS8vj/i4QzHnLZpHZgVgnOTzxNScKTrcuZz04wPEa81mnzexcVjc+ty13txsR3p2QQbNwqi5GC2nKN0Ypb16tkrrAqX4vBO4rxXPTo0MZU9R4vuq0ozGiZG+6yhq9WzesfFvAlbLTWcr+9IhU3F7a2zLToA3b41q1ASZ1YwhbUKeHIOQp9biybN9kLL0WiydEhUS2qkJakUtlfPsc+qlPAXyJHrKmPC7aOdc3NQUIdPa+O5FkosW5fH8yMb1byh8eDejcwk7fCvBNLeyvwVj3Q0p5has80xfammt/kAp01qVc9tbm7yj25GgPId9XhB5TW1OTQiqSpTB80hoXg+FTh9o62gQSqWxChVUHBntxdo/EimKFkSpGq/GckIjBdHuth/NlpvmztxMCNgJCbqFx/WOyHi+AFJSvI1S6fTPTW+J9gF2Nh+FeTUa3YejumBfACdkom1nJBROZp+npXkU5ZR2nr1i4/4xUkDcCOyXvp/c41zqV1pfoTjXxkK80mskChKaR/7diRTCHSJ6qNS/llIGrmvn9ONVfV+t7GeHo9nbyL9f5Bn9BEr5VES07mPn7HR2DvyOosbuAGYp/Z3pKTmFdIRme+/NwJ7JOKQy0ErIaa0JODEjncV+syOlaAm7vihyvvsSyUfnIEVpw9YvUkIXNQe3sj3/Z2QU24Q6CkUU2dEEXJp7LrSyj4XRZlLkyHUPcjxY3865O3LTWIfmxxHvP8z6RLz0zci4cTgwdXJv/vRzR2rIyetTTOGOZOjPbF0U2REWBy6gDXjXZB/tjgyXKwAL13muJ4rkKOrZHADMXG+eIT6xMrWREtoeBp5L+13nmUK/dCyS5SpVw43ESFnnHfayvWwJYJvctHrz1pYtOwHevDWilRj5T5F30CLGDFyIlOnD5C0nCYOtWkNKuf8iBdKtyfXupf7OjcKLj20gbQ+iOi6Fwas4UMellkLma+S1UhSAHGo/18w9tq3sY8HY9EfC8ufWl4+BPZEXSPfk+WnsPeyam/YxpSHh7FVjPos0CI8jQbQo6DwRUmxvkInGQqBfB+ULXzO59z+UWm93JGS+hzwzF26J4c7dbD08iDydhpDU3UHGqHeBK3LT2Vlasrf+9ZPmnphTIYPBn7a/Fh5oTUjYX7QCfSin+VjI1sKm9rmH0foTyrddCM57ZqK3p/1cBKUp3At5Tafe3vMCp9k5+CNwd3KvUl6LyPHjFmDZOvfWsP3xfkrpk6zP/wVuyN2HNhqH7sBSSHn6EJZakAo57Bg9ldz7veVpKLLkKZJ6OyjC8hTkgNYFOW19aNeHibrsaA2lpPzF+ImLaM5rl2sZ7gMsVr6XgebNkdK0u53TPUv310fRHg3dT5HT2XfAftT40T6Ib/4CyWr/Bpaq891xqJjBnuay2VTUd6bb2Pb5ghd6k1qUfSX2exQR9B6wV+n61KjWbhPisX+032+lok5dI9nvlZHBcCH7XNTVmyl55mgUJd5mNW5QfcIvbCw/Rw6lXYqWPDcjtXo2jyMHqGLOVfJsprkhZgiweiu+cyKSn7Ma/xLaZ0a1p+5FDo4HIuPkWOlz3rx11padAG/eGtmQ98PnmIHGDuNvUC2YIt3K6sDOuWltRV/mMUbzE5ROqczYpd6wXRp1oAGTI8PMn6io+xTJobs3Uhruh9JOTI4U68sh74jNco/rSPSzUJJeZYzeZShSqEjL8CzyUJuAiinpxpRm8/4d4DD7vLHNy9SQsDzyit80M62no1Qehbfj9khZugBSWp9o67wJy81dhVZPSEH5ne9Gnr5fomKiRU2hJ+kERVKr0lBUSlH4vvdwnpsPGZP3Rx6C2Y01w6F1Kpv7V6BaU3cjT8v97f64dvadmpnOKZG37p8okmkDrLCx3e9q/MQdVDjNKkqn8jMyEh9P86KufexaE4oYOtf6tAqKsvkV89xvFI/RzmMxL/KIr0xR9oR/WpEOGBHhrc3mQaFQX58kWgZFCxxGLZXQ9kjOmS955kJg++Rzh07FAsyBIhB+tr1pV2CS0jO5a9kU2R2WtPG/GTke7Jk805XmstoAatGljZLZzrbzdd7y/wVmQdHSPyED2UmUFOW5x7lES1pD7j4k3/+Mooo3oxZt0wcZ6LdBqQWnS79fhUbNoWzL5NqkiC8aYnNqPsQPXWzrYLvcdLdBv+dEssLqKHJiEDK8Fs4yk9gYPNYG/6s4W3dFxskrUBaQZ5AhcyAysI5tz6UG4dWQPuO80t+szHqo0995kJHvLWDp8jmQ7FkTIV3G442msURPsZ57If70SxQFfbPN95uwTA4p/d68dcaWnQBv3hrZgIOQd0bhZX8WMnrMkDxzGVJGVDbKJqF1EuDv1PIL3wEskdzvSoNrqNjhujg1RdBHSAkytTFBR1Mr+tshlTwJIzG/MdU7J/fuRLlgH7F38m8ktA0T0uutXd5NmjIkoFR8rxqz+jEqLl0w4H1QWoFPsbR8uRhuSoUIkVL6goTWRZF316xUoDA2zVMozYgE4HmS+5MgA8EtKNXGc8hYMEMOejtro1YY+D+215yECnUuSp0c6FVqyPO4CVinzr1dkNFvqP1cP1kLM6A0gmfn7oPRswIy0g9GCq5lSNJ2AOMVn6t65iFjxZ0oHcbjKKXnpMn9JW3Mi3R7Tbav7mT3K6Ps6owNeed/jJRJHSaFrLc2nwcToojur5Eis5Bl0vSGO9j9+ezzJMBtwM256W/jsRgXKXYftXPiZuQAlp3Xpnm6ni+R7PM/akamh0v8Uncy1LtE6fOKVNY9k+trYMXK7fOKyDHhVxTVtT8VdL5Jxv0KWwNnIxn5LmToeAZYLjedrexLfztj30COUBNScwo8n+ZpWadABoRsaQDbuO9X2lp5BdUQTCNdNrV5OFqOdslc6WN76slYGlgU1fEOMubcjyKerqYUbWzPFobADsEDodqLPyM9xeaoLkyP0jO72Hxayz5n4VupyZnnI6ehVe3zjChDzqHUUuZV1ljmzVtbtOwEePPWiJYczrsjr9g+yIgwGIXAFsqtqZBX77W5aR5Bf/rT3BtqDpQi4FMkIJwPTJWZxgHIG/c2YzJ/NNpmKj033PzyVW4ox+6j1Dwcl6FWeH06pPwqFFz75Ka3s7bhzR1kTPgcGQ+/pXntqrWR0fYM+9wwppuah9ekmCGGWp2MWZAh9qDk+Q2Q8DZ7o2hszZijFFBfG4P/ne2fcyXPjYtyQVcqhUZnaKiO1gfIa+5qpHR/w861D1GKsZuQc8KOdk7MkpvuhP41UTqYje3z+Mm98ZACbnWae4z3sTN7EJa+qgqNWh7zL2yfOR55jPbKTdsI6C7XgdgIKUm+RgbXjWmuHFoWWMvO9rQAcuXPb0qpBDtSQymMdrC5dVJHGndvbToPegOrogjvwbZ/rkviyGFrswmlFVrNfv5BrUZEJQ3HozgeXZAye087835CDmNzUg3nloORA84y9nkBex+fICPCxcC4Gem7Dxlh0nooA2z+HMewytydjd9oAhbJPb4t9GkSFFmzV3JtUjvbnqSWGnba3LS2oi8bI9nld2opxK+jJDcjmeEd4MzcNI9mf4v+TI8MbYVx4W/I8e4kJBs92Ab/q5DBLrOxK+T4bigLyM9IdnwMyfnf2HvYs3jOfnYUY03K522GDIJDkTPgIcCGSM68yfr979w0G60T2J5zNMZzIqPs65hhGckFzwML5KbXm7f2atkJ8OatvRr10/ZMYszyGaiuxdMkoeio5sIvWF2JKh7GyOP1FSS49SvdWw1F23xrh9wR9cahwfROhgpbFh7h1yDlYeXGdiT71Rs4E7g6ufYUKnxfzKnV7dqRVEhZ2llawuB3Q543R6DaMJOV7q9n674Ipz4O1cX4CnneFcx7w+ck8g69neZe7UXhzeuRAL2ArZs3co95Ok5IgdsE/MPW+OnGSDchQahv8p1KRnt05IaMYfsgQ8GGxbtBNQ62Bva1d/EJMqr9Yc++QwW8kY3eonB2F2T0u5XEeGP3UmHzICS0V7L4MRIwz7Dx/gClKqq0Yp2SEhcZoA5BkR0fojQsw9S7Kb+bqrVk/+8BjI14vNSbvMPxIMBRtqYPy02Lt6zzYBKUfrdQQt9ifEIx54uUhk0oeu6C3DSPZn+Lfo2NItw3A2ZHabCCtZls7y0cxHbMRGvqULcOcENp3wnASigy9hfEhx6e9rNBdC5n82MXmkcyXICcP1JDTtqn8bAIyyo2JA9cRSmC13iM6VF67qK2auXTiaFI3pOR883qmNxPLcKjKzLu/A4sn5vekejXcOe6vaszk3c1BEXYnEcb1VlBDnNNNifSWpCHID3K2va5HzJofIgchhbKPX6j2e/uwBLAqcioXJwVQ20/OpBaFGdWI7+N/dvAAfZ5EaN1U2qy+2IoGmrj3GPrzVt7tewEePPWlo3myp2x7EDe0JjTBez6LskBdSIwvV3fBKXweTR3P0bQxyWRh8TvxvTPS+LNa/3ewRidm3LTazR1R4aaw5Ay+kfgGDpImg/kpb5wC+9iRft9TuvbTsn9zWxOZS3k11kbNUH+YGOmC6bzDkoe7ihH71lImP8GKYiPImM9BqRk+A7l1C7yNRd92h950r6DvN5/xDxlq9KQcH83tQKuPZDi6FSkKPqVTMXix6Rm8/8PFEmaelxvgiJLd0AKrg2R8e+ACtAcSp/7oXopnxnNh5fudzHB7HlkzGz3YtplGkfyu3Mgg/3uucd6JGg+jUQZgVKuXGb75Su2X86cm85W9qUQ5qcF/mn70bOI51u69GzljTc0VyidY+fYZvY5jM5c9dZxGs1lnC4oVeT+wPt23p5JzWllSmQ0ng1Ln5aDz2mDPhdreXrk5DLY+joU1QFMo6fHsnPi/8hcIxM5s9yNUpf2oVRb1M68zW1fejEDfXsZ3/AhknF6GZ8wFNV66VJ6PlR9/qA0qj+grBNFDbxuNDdKjYUMfxdjdXyq2EprvZ4TauE8NQ9Kx/2f3DS3tk/lfWwE35kL1V9Zy35vs/Pa1kAT8LL9/W7Uagn9nVK0nj3TBGzQ0nupQmstT4AcBCdHuoztkK6sUimskaH+VeBG+/w4qpE6oX3ujtL5fkSFou+9eWvrlp0Ab97aowELG6NcGGcGI++Bf6Ew4iWS+++iUNAiz3BRCLyyzClKB7CrMdvfo7DRaWhe0HIKSh7LuRsSXBYDLkFpDL4C/pabrhHQPA61dADnYJ7hdZ6bFCm3DrHP49t7eZfhFAj3NsrvpRBYFkUGjQuB5ZGiugkJnWPZWpk5+d4AlBqx3ZW+rehDT6SEWNI+lxXZSyPB/wJgpdz0Gk1FSoBxTID5R51nxkYpWq6xd/GRr4F2eRfFGuhn8+RtYFG71h8p8q4nqa9SpUZNGTclllIPRW/9CxluPk7PB5Rqb0lgYANpnB55HU7QimeL9zFMKsDy2q5as34OQkaacnHaxVFk8reIb9qz/ExVG0pr8h3yvL4FKWPeQMabOdP3U6V3VI+WZL1Mk/Rr0dy0esvbkLJ9QcSf/mz75u40lwcqb5hsRT8fQ/XxdkdG8VOopSNOjSFd6u3BDaZ1EuC/SD77A9gtudeV5kaE6YAp7PeG7auIP14GpbAeauP7iu3xLaZsq9I+WYe2TZER7Cckey2a3CtHlBaGzMr2Z0T02bld1FyZMTetrexPd5QVYd7S9bL8Uza0tbnMhnjPjYEnbC+5Hhla/4c5o9lzhdyzvO2xO+Qex+H0KR23unqsEcyp3NlZhqHZ1vUXSF7+jea1m+dFzly35B57b97as2UnwJu3tmrUFCZr2gb+EUoPsx2ywr9kh/KvwAnG9G9sh8DZKL3PuPY3Ks3EFf01hu1U69NrKLJj4pYO6qo0ZNBYC3kir5ibnhHQ2hV59xyBIh6+Qd45vUvP9TZh53vg2IS5OCgH3WNKM+b6Tmq5bfubEHOdrfmfkHHzciqQoo6ap9mOSOn2I7CVXWvmEVj+TlUaMjb9ZHP9MWoF4ruXBIZJUGTjHrlp7uwNGdEKxfrCtl/9hBkE7ZlKKtpR7vL/YnXYkKF1Y+AhO7MfJVMtJ5QmowmlUfwbI6hRY2v4IHsXA3KP7Uj2tfA6PbMeD4EK2H5NRVPT1aF3IaM3NfzNi5SU3yNFzZ400AjYSrpTBfS6yAA+HuL5iojMATbHXgQWK3/P25jXaF5HcihK/7xicr/DzY+EX1rZzrN0LT+H0t1OYJ9nJql/lrshB8G9jc4mVHduyuR+Jc5j4x22oJZq7/9I6hJ2tIYiT45AhoyhKMJ+QHK/w62DFvo5s/FIL2DpcTtCQ5HfTUhPsydmsLR7dWUd472uJ3G0aEN60ojFt422+4BpUpqopSP+nRqvWinZzGi6kqSek10b7pyvaD92Ag5HTgljo4jpoj7y/kjOWRVF3nxJ5jrO3ry1d8tOgDdvbdGSQ7W3MWq3Uifs2RjTj23jPz033SPTt+F87oly3n5mDOr9wFK56W5l3ybMTcNI0NoXRWidY+P8KKX8wSiC42KkjP8IOCU33Z2xUfM43h55PS2L5Xe26/9BxrWrkQK1iJR6jooUHzW63kA5zV8GZk3udaNint8l2qdBRrFXbVwvoLmisUcu2sbERs1hYRqkcHkeefceRanuWdWa0fwBEuTLKQ2nNyH5DUoFeBtI36Q098S8BaUAHCZ1jP2cH+UIfyH32I5if4+282v3ol8099jvTS2nfuW892medmVeZAz8q8Bwcm9dWyef21meNUc9UkrMUrq2hc25b209PwFcixSSy6BIg89RZFqnUER6G/2G6khubfN7CHBGbpraoE/7olSxRTrb7W1NpJEUFxgvNcKoyHamtZmnO6rBcCriSX+z9dszF30t0BxQ1MHfUWqxH1AK68ly0zaK/emDoiIuQU6NXwO75KarBVrHJTFcjOR3V0Ap7SopKwyH7jWo1aq5B6Xu7Zfc70KNr50WpX/7up1p6pWs1R+Rs98u1GrUzoF41QsLGnOPY50+TIUizb6mpKNIx7SKDRnO1kS6lu42Nw4F+iTPrEPzGjxNNjfWyUW3N2+NatkJ8OatLVpyuF+GFLSLla6nwvoAVPh7MLB1+lzVGjVF0HSoePo45XvJ571QOPhnwPa5ae9MjVpo9ITAzsizqWAYbqS5wr2PtYFVnVedoZmQ+aUxpmMn11e297IJzWs9FYV5/56b9oSmpYGLkIA81GhMjR+V8MRsgfZeqDDn7TauHwNbJPe74MabHO9lOTsDBpFE2VS1IWX1zcAq9jkwrNJrflsnN2SisV7tiNMo1SpDHsun2Xoo0qxWdg0ndP9lIEZRsLcgb9JVS88UxvLKKYjKtAG7IS/8N4HxkueapYxCSsoPyJxK1sb8LWBLLPIHKS9msWu7Wn+esHPvjxIfcj0wSVXfj7eGzKHUYNkN1bI5nVpq3w5l2Cv1Zwub88X6/gpFUPSyz+OjaOp7GEE0ZKa+9ANWQ0bXwcijf5vcdNWhsyswNzJ2/GZ0bknFnT+M9omRE8iUybWJkEHgbmTAfJcktVIVGkrL/gSKkmsxLV1naAzr7HKA8Rq/2Zxbiub8X1GvpAlYt0E0jkvziMXHkZPHGchJsGe9vlSlIV71IGS0/w7VPp4+uV+5c8B4sb2M3uuR89kb1NJG9ig9vwaqX7VcVd+DN29t3bIT4M3b6DZqhpnZ7WDfCfO6LzH9qdJhVuSJ8HBu+lvZxx2tb28Bm7bQ/1WM+ZsyN72dtaEopheQB9quxsR9iITJE0iUQ97a/V0sZWv4W5ReaWm7/pIxfYV3VA/72Qt5JV+Zid5i7+lNEmFmdK2HjB+DUITWFrnHdzj9KBuLB6Ic8/+1PeoJMnutj+kNeV++i4whU9m1ygk2KLpmKDJaHkopuqz0+9hkrovEsLUjPqK5J+bKKO3Wefa5csJxvbGtc68nUn5+CKxQ9b6U+4QUAHdQM2jcTpLv3+6nkZlFesdsfQRWN/5uKIooW5nESSd5bgJkzFkM8bp7AA8iQ+J+ud+Bt2o15EB0F1KA9c9NTyvoXYbmtSSCtalRTYMTgPNRNMjUyXNLAp8Ua6DR512y98yJFKZX29mwKEktDhQFtSVSqH6Te7yH05+xkEx5r+1Jz1MxgwI1nno6ZJz8DUWufwlcQXPjzfTIkP8pFfPKBza39fkbihZbKDev04A+p460/VFNxsL56ygsHS7S1bwOPJqBxjRi8U+jb7cy/VVpDGvYWATxqu/bvD+K5o6MleLpEH99jK2DQShjxhKlZ7q38F13VPHW6Vt2Arx5a6uG8vG+j3m4tuL5M0zQrRQjmtBXRHdMYszDyijtWxMyzixcen5rlK5oqty0d6ZGzSi2rc2X1Pu4D8qrWjCcrwLbVJGh64wNhaufh4T1L5DB4DdguuLdJYLd5MZ8X5eZ5ltQUeyFaC7Mp8aPwahWz5y5x9hoK8awJxKQJ0UejKnX+pxIofI+EvJvbInB9jZa72KEwom9p6IWy/m5aR4OnZug1AbfI2F95XI/qWCaQIatHfEYqid3HUqrUXVPzOJMmwWlAlkNKUt7JHzHjMho8xAV9rIGFkfRNHPUubc0tWiUh1Ex27S2QXeqp7jYGxkEvwNORilZR8hPoDp6TcD6ufvgrVoNOBI5rLRKNspI5wLU0mCuSvMI6u5IZiuUp+dj0XHGS90EfJo837AzI+GPZkeRKb+hNG1DgVeQsnS+0nfmxiL0W7O+M76TAcgD/rzctAyHxsdQdPHFKL3nrXYODwL2TudEVdcAMsQfhhxYinq8s9I88r5SfFAb9DnQ3HgzN7U0tE+jejfn2OdcNQ27GZ90DHBt7jEbDp0ToVo28wFjJdd7oJRi1yNj5quUnAIryAN9YntoEzJmHkYSKWTPjI/SFk+dg0Zv3nK07AR489YWDRk2Hkfhz7fYwVX3IEoY7DORZ+OAKjNDKHXHzsgLYSDy0nrBBIKrgLXsUHsXuDs3vZ21IQ+oz6gVJ0yZzalRmq7Cs3ef3PR25lZer8BKSIH6rbVDaW5Q6I7Cqf/AQuzJoFBFRqTjTDD7GHlkzkJzr+85UJq0H6lAbSqaRztcjRTsRWH2vSgZllC4+i3AFblp70yN5h5yrTqvkAK4CUsDWsVm8/1ganVrLgUmGtm+ZqK9nifmznavsoq4hP7TUWqSQajewo8owuYyYG1gP+vTQ8m5VylDFBLchwJHtEQfMob/bP38F6p1UKn3UzoDeiOj/Z8oP/2+lJSN1PjYIqp8EqQwviB3X7xVp6GIiVvpOFkFDjIe43uUanIhmvPa+9la/gV5Yt9u+9ZbmENVrrUNPIWcB1ezz+tTkwleQNH50+egbTT7FXKN6XBoKhwPNrO5sE5ybxxUG+MB5AC1Y256W9MX+30q5IQwFEVQboaly+ysjVKtFWAjJGsXaye7wdDm1Dj2e6WMHEbT8sbLfYUMl1OX9s0itfvDyCHkAayMgN3PxmejNJ5TJJ9XAOZCcv1LNgf+DznOFlHRG9sZMYyzjjdvnbUVnowOR4dHCGFSlLt2N3RAXQCcHWN8P3kmxBhjCKEfcCEKy10/xvhTBpJHiBDC6sh7aMcY4y12rSvKWboaiuqYATF4LwNrxhg/yUNt50YIYV/gJJRm5W271hWIMcamEMIGSEl6EnBbjHFwPmrHDIQQusQYm+z3Hijv+TbAzEgJfGaM8aoQQm+kuBg3xjhvNoINIYQpkfflZsBzKDf7wzHGj5Nn5ogxvpyJxL9QjHEI4RCkXC/yDW+MPNmfRXvUfTHGD+074wBDYoy/ZSK7UyGEMBGKiLgKuL/YW9L5nzxbnHH9UXqEtYEdys9VCSGEnkg5tx5aEyDPxtNijEOzEdYKhBC6oTN4I6RY3yAzSa1GCGFiJBBPhtK+9UNG13FRpE1XpPTqA5wSY9w/E6ktIoTQBQn9r9i8fxR4IMZ4ZOm53kgJvD3y5LwVnQ/vNJrmegghdIsxDgkh/A0peye3W+Oh1D4PI4PmAzHGL+07IZoQZzztfcDPMcblGk2/o7oIIXRHyq7vctPSEkpzuTdyqtsGGTuuQQ5p/7P70yLjzXzIEPsiMla+kovuEMJKwD+R0f5Gu/csMqT+Gzgb7a8PIqeWa6p+tnUEhBAuRHzosjHGj0MI3RP+aBY0d3oBC1Z1/id7/yZIhzEhMtz3BqZEDmkXAs/EGL/PR2n7IoTQNV0TIYSjkaFzshjjr/koqz6MD5oWpRzeERm9TkBG7W8TOXkWNMfWRqlWH0QpJT9rNL0mVy6HeP0+wKL1dHEhhD1Q5oDeiMf5DBl2Xo8xrtFAsh2OvMhtNfLmrS0b8tiYlRZyzifPLQC8Q807szLevNQ8iLog4f1FYFK7lnpOdENGp0VQfnOvp9K+72VqFF78FLBAnftbo2ivqXLTOqY1mntpTYo8jd5Cnjg3o8iVJmB+eyZn7YI0cmVxlNphKBIuVyapd1OVhiKVHkRCQJ/k+tLAaza2N6NopqwFvTtjQznPm1Be6pOAeVqaU8m1bVBdjzlz01+Htv5IwJwgnS9IQb0OUmoNQikPl85Nbyv7VGlPzJHsy0CkYFwJKQHOQcabY20vqAS/VKYDFaK+z2h9lySVafLMLCglXxMVSZVT9MN4vs9RsfJZbax7oLRun6L0rJfaOdG39DdmRw4AS+bujzdvo9JQREea2mczW6c/27reDJg4ud+/3t/IRPshyCt8Dvu8iZ1hi9vnLVFESBNwee6x7izNzqRBJDVgkLNBIUdvYWNeyQinZO8fAPxk+/vUKEJuIKpb9imKhD0e6S565aS5AWOS6jnGykVHR2woNfIiSB4biiJqlqvDLyyFHJv/ANZuMI3FnO+K0kf+B1jGrtWN5Db++hxUx/YblEbPZU1vY1TzSBtHp4R53S+GcqKuilL5HAvciSz6RyIl+8QxxkGpl1dVEEI4BnmQTovq1/xi15t5ozjaH+bF0gXYH6Xeehu4HLg1xvheCGEx4O/IuDZHPkrHXIQQAijsyT7Phwy2yyJP8itijFvUi05oR5pG+L/MC/Yg4AhkSH4UOCzG+Gn7Uzh8JN5QU6NUSs/HGI8ymofGmvfWrihyqD9wfIzx79mI7qQIIcyIhJZlUV7qy4CbYi26KSCBZ2gIYTaU33qcGOM0uWguUOyfUd6kSyLPukWRgvoB4G7gzhjjz/b81MCKKHJxxxjjQ3ko71xI1nN3ZDAbGGN8Nrlfl7ewKI7jkXfmirECEYAFCi/l4ne0B62MjE2LIGPzztGiY5PvzRVjfLGR58GIEELYAtXqWC/GeGfp3nio1seSKFLoCuDwlPYQwqwxxlcbSLLD0WYo7U+3I8e0P1B9g8WRUf9alKb1sWhe2Q3m6XojY9FnybUuKB3XUjHGPeza8+ic3i3G+EMIYVYU6bcZ8FOM8Y8q7T1VRjIv1gf+F2N8Lbm3LHA/cAlwVCxlmgghbIPGffUY4/81ku6RQQhhfxTJvnKM8cnSvTnQnJ8ZeA9FvV7QeCrbDmV5rYX7wdfHqMGyHayIZMtZEb9wFvBmjHGQPdMbRbfc32DaivV8GrAuygRwd+ne2CjaeAjwe7QsFCYbjAN8HCsaOedwtBe65CbA4WgPxBj/NEXPpsg40wOlw7gKpTHZDkXZDDKhvzIGmyD0QLn+18AOXGP6KZQqJig4GoAYY1OMcUiM8ThgK1QE71Tg0RDCS0hoKIyEjgyIhmJdxBifjTFuhequ3InSJjacLIAQwsEhhI2NEf0LJpgMRcr4R+3yMij8OzuMeZ4TKVAmRt5/xBgH270e9vkcVFPhKpSWztGGMGX6mzHG5ZHivDfafy4KIWwYQuhn03+oCWLroPNj84xkFylL/9o/7fJlaP88DCkiVkYF188IISxvz79vSokV3WDTNrA51BRCGICUWM8B94QQPgkh7BJC6Fs22CSKlR+RwN8d2Li4XgUkBpuDgX1jjN/EGK9A+c8PAqYB3gwhnFPsV/a9F+1nNqVQUHrVFL8gXrWn3e9ePBdj/BadE5+hnPQ/2vv86124wcbRSXAcknsuiDGuhtL5TA2cCGyA1sF+IYSFzOGukWv4MuAuc4wA/tpD7kWRyIQQJkf6le9jjD/YY1MBM6GIjz+S7zlGANvnJkTp5x4JIewTQpjAbj+FUvZuCxwVQljMDNxFKqhVgC+rarBJ9u8fkUNpsef3LJ4xJ4nTkMHmKxRx2WFhivk4PL2L3fb1MZJIeLafgBuB1ZFD6arIQWqfEMIUpvf6rTDYNJKns/U8EarHfDGKfE7vLYCcbf6HUnGfF0JY22h+P8b4khtsHGMiPNLG0elhh9FkSNm+FcoR+36McdqshLUC5pV8GEpD9B/khflwjPGbrIR1YpgQWCjbp0RM/8QoRcPlpjwhhLA3ClXvg5jpG2KMj9b/q45GI/UaD7Wc0Q2PUgsh9EUM6PzADUjZ/kKM8c/Sc1ejFCD/ajSNw0NQxNK/UV0FUDHLG2OMX9v9LigdlNdwamOYkW8eFG35A3B7rOVr3w9FjAZk/LgyxviQCTw3AU/FGNfNQjh/1Ut5GHn4XRdjfDuEsDhSvGwVY3wkee4wVM/ma5TW4fpCqe4YNRTnWEjqrtn1a1C01h3IcLMSOuNeAY6MMd7Uwt+bFxmWj4gxntSIPgwPZkwuar30Aj4E9kWK3t/smW7ojN4Ipcn5EzghxnhKDpoLhBDGLZQO9n6a7F3Njsb4flRrsXh/mEF2TuAMVLuwiDKoXJS4wzGqsDPvcZTecMPEsa4wzq6BzpQu6ExcLcb4UgPp2xlFgC4VY/wkhDAN8EVM6veZzPk4MsBui6L/dkJpladuFK2dCeaMsjRKO7ceUugeG2O8we4fht7LEHSu/YJqHvUDNoox3p3OoxxIogh6An+m+3YIYRmkVD8zxrhX8TzGWwdFFB2DUll9kYP+UUFJnp4T1eKdEqWuvwL4pEryTmeEOatMj+oDbYUiAM8Fro2ZagWZXHkHcrS5Mrm+FjJQTo4i8H9B6/1lYJVo9fwcjjESsQI52rx5a0RD+TPnQZb9Bexat5w0JbT1R2kvVgQmKN3rQa2w3C/ARcASdPK8tjnnif3cCqWrakKCQBPyhjo+edbz7eZ5R92BHq18tm6O3AbS2gWYCNUYeQcZ/05Civie9sxkyGBzXgXGdpjxQp7fWyDF6G+2By2Z7kFA99y0d6Zm59WVKF97E8p3fkAxZ+yZ/ihNYxPwMYpYud72q4kz0h5QKo8vjbZHUNRPkdpt2mJeJd9ZALgLeZK+iVKCZn8PHbVRc8o6EasLBCxo63en5Ln7UHTck/aurqJOHSR7Px9QgXo9tjb2REaY21Hdv2ep1f7rmtKJFHerI+P5OxWg/z2jZbLkWjf7ub+9h1vT+3Zvc+NBFsrdB2/e2rrZudEFOag9b+u4S7KXFbz5jUihd00mOgu+bRFUX2Ev4+fSeoUbo9RuP6DIiG+AtexeJeTOjthQRPcmyXl1h51NYwHzoiisj1FNy+upU9csd0NpLpeoc/3k5AyeJrkekA7gSypSh20k+lqca9sj+eFP4HXEz/5GqQYbmeW1jtiSfXEyJKedgPQXC5ae64PktgftPYyTkebpbK7vnVxbx+bIJyjdZA+7vq09e1DusfbmLWfzSBvHGIcQQo9Y8nLPiRDCckgZtyxStt0D7BlVKyX1UpkQpfvYGR1qNwJnxVIOX8eoI/GEGoCYhwdQqoZvkdfWGihVw0vAxjHGt9zTtTEoomQsLcVWyPPmylgxL60QQn9gTiREvhBj/MquB5TiYztUa+db5Gn2GcrXvhEqWvt4BppbzK0+nD3oS5RH/CbgVV8DbYsQwslor/kHEvJPQvNkBmT4mzDG+K49OycqKrqgff3wGOPRjaa5HoLqHR2LDH/3IWFt2Rjj53a/OzAkmWObo/W9bEtz0jF8JOfYasBtqEbKjSGEC5DH5e4xxldDCCsg5eea1OqkzGp/Zu8Y4xn1/m7DOjIcWBTNpijypA9Ko3Ec8EhMatzExLM6hDA+crT4JJfXtaXuORDlcp8SODnGeECJxj2A3VG/LkWGzrlQipNXYozLNZhsh6NhCCGcgqImNooxXmvXusdalOmFwKcxxqPsc5Y6nxaJfyFKafsMcDbKhPCl3Z8EpeUdBDwUPRJ/lFHiQ7sgPmItxItOgLJQnB1j/DCE0As5dv2WnAVZ5bREftkZGZZWijHeV7o3PdIFrIvmzA3A00g3sCrwnxjjenl6MPJIon3HAT4FbkH1Ot8PIVwJLIeiJ57PSWdHRjJ3JkRpwOdG6VP7Aa8h/u7qGOMr9nxA6YknNB4w197ZA2UIWBplcngPOAQ5oq0eY7wreXZm4DGk7zqy0bQ6HJVBbquRN29jckOFNt8E/os8UY5GHgUH2v1hPCFQrYK77bkBufvQGRsqqv4xMG/p+kCkUBkCXJqbzjGxIebtVZQ6Izs9RlMX+7kcSm3ThDyZbsOiCpJneyED4KXAYCScfUYSwZWpD10RE70vEhCXLOit8+xc1rcmlKZiGxIvU2+j/S4KL7R9ijMARa68jhTTb6OoyyeQ8bj43sbA4xWgP5Q+90SKiiZrjzKsF2CPlr7vbZTfw3vANUip1R2lprshuf8MMrr2s8+ro4iVE4AZ03dBBSJs6s0P6+OnqDbYh8ARwByl5wcCWwJT5abd6OmJPF4vQQbYr5GCurg/NjLYXoOMaU3IyH8dMEXV3oc3b23ZkOLuAeOzj6d51Nzsdu5dl5vOhKYVbN8cjKIklgH6t/Csn21tN+69kKPKucYPfYzks7GrNN7JGdoNRUqeXpy5dj2NuOyJHLvutXOhiLK+Bhg3d19Gsf+HonSH89nnCYHfkazRy65tB+xXhffVkVoyt25AEdNb2eeNbO78gAx/uwCT5Ka3RPsiSBb4zWj9L7BJ2i/7fRngc2Cv3DR785azeaSNw5ERIYTzkIJ0kxjjY3btGsTQ/AwsitKjXYJSAXyZfHf6GOPbjae68yGE0DvG+FviGXQisBkwc4zxx3J0VgjhbMQEzejvoP2ReI7vhBSKm8QY78hNFzTzJuuGjEk/oRSMk6MCkAfHGE8IKhb/Y+m7EyDPqFeAr2PefNv7oVRKQ5GnVrT2OGKq70d5qL+MMb5h/V0UFea9NMZ4XBbCOyFCCPcB4yBF7vvmHTcD8px7FymtxkJ1kqZGaTUOjJkZumQtjIWUaysAt8Wal9+0wCkosuN1LFIrxvih3e+KhLVs66CjI/G83Bc4GFgZeNauLYwcPe4KIcyDonr/Dlxm97dGziMbx1Kkb5UQajXKlkdOLPehFDInUVOgXgrcGmP8IoSwI1KUzVTMtVwoeYyPh/i//YFZkEPCfjHGp+3+hMjYNiFSSr5r52Al34vDMbJIzoxtUGqf9WKMX9petS+wNkqZeStyLFkMmAI5VL2ey1O8DIsY3Q7VZ+uOUsheC7wRY/wjJ22dHZYZYWGUQmxV5IxwRIzxXrufdY4k8su5KFvDmjGJLgkhfI746CNiLZpsPFRLtQfiv9/qqHt+UL2hDYC5Y4x/hhBuQPzsKtEyhYQQrkJ93TpavTZH6xBCmBvJZwcB/4iqgXQTcla5EkW6R2QIvBO4oipzyWSbZRF/80aM8Qe7XvB4/RAfuxMybvrccIyx6JKbAIdjTIUpsHZE6T3+a4cXwPdIeFkeedp0RwqH60IIA4vvu7Fg9GAh9oQQFkUePiSMzBeIYZ7Prv8ZhB52/xFkWJuwoUSPoTCBpytKG/A4UlqTrJm/EEKY0QwKjUJBw1lIkb5XjPGiGOOhSGifMYRwFvBQCOGVEMIeIYSJAGKMX8cY74tKFZVb8fAeqrlzBPJs2gL1aWyUxudClCP8sRDCcygVyErIsOAGmzZCULrM5VCqqg/hr31pb1RTZKsY45aovsWuyLtuL5TXPSuS/fMQFA06P0rTUChO3o0xro0iOsYCTgUuCiFsaEbNoW6wGXWYAnRoUNHmQ5F34vuFwirG+GSspZ34ASlJett3xgOmQakzPrPnKyHYl2HCfC+khOgPfBxjfDnGuBLwNzTnzgcuN2XQ4cjp5cPi3M8FU1B3t48roPoMXVFEzfzAkyGEa0II48cYv4oxfhpjfAHV4mkq/kYW4h2ONkYyl6dEBpn17fqTKEXgLqh+yerIgPMusI0ZbLpUwWADEGMcHGM8DzkrXIEiPm5B57SjHRFj/N7OtZ2R4awncGcI4Qy7n9NgE0x+mRYpnk9Hzl3F/d0RL3SrKduDzetvY4yvxhhfiDG+2RH2fJPR6uFnFD3e2+TtdZAh4Qv73kyoHsuPrpRvGYnOYgYz1BRYCkXivmhzaHGUOvDoGOM5iMcIdm3VKs2lKDwQY3wqxvhDIdMncsC6yIH2GJ8bjjEesQLhPt68jYkNFYN7E5guuTYu8nI/D+UcBRVXvACFj56bm+7O1lAu/P+Urg0E3kee7WsCfZN7PZGy9Bdg1tz0jwkNORh0Bx5GucGhecqMImp0IZRGoCHFOpP/O62tz71tfhTXz7frryOv9jeoFWYfmHtc6/RnP6Nvn9L1sW1cP0eREtdQKzK/Xm66O1NDBpg/kMFmR5QCZHZk1NuaUhFjYDV7D3/LTHdRDHVbJIyfQpLyLH2mNN9+Q9FpN6HIxuzvoKM2amkaL7E58auN7W7JM0Wx797Gg/yC0oFehxwR9q/3rqrWkIL3Oaygc7Hn2u/dUGrBr20u3opq2fw1RhV4RzOj1JinYCk0kbH8dHsnf+DpQLyNQQ0Z8YegCJvuyfVxUH2ncqrZdk2lNDp/H0UAPoXqh2Uf287c6uz9s9k+2oTSsmY/y6gv7/dHzhPHFvOdmuwQkCFj6ty0t/YdoFptc6Zr1+5NhuTpS1A92DuQswjIYLWdnYUL5+5HR2jI6HdwwtOsSJIuEkXd3AdMbJ+nB55HzmDFtexrYgR97I0ihz5C0fjZafLmLXfzSBuHIwNCCJOhEP+pgV1CCFPZreNRpM0pwDcAMcbnYow7ooN6lhBCz8ZT3PmQRGk8BcxVRD+YZ9RnKG3MFCjC4IgQwupBRea3R8r5u2OMrw77lx1tjRhjU1TagJ+Bac0LeSj8FUZdeA5Nj5R5EzWIruL/XoTqjNweYxwUY4yWsmEDZHBdMsoLfBN7dnE0vyqBxLvpZBQlsXsIYZPkkZmRB/vJqMj9hshzbrEY4/WNpreT43xgFSTcnosEsKuQcfmWWCusW3g1FukzejWe1BqiojW6ojPsBlRg/c80siFZs93t88nAJMDtyAvwq0bT3VmQePTOgYx7ByAv9f8CZ4YQXgshLBeFphjjbygt12323CLIKeQk+5NNGboxXBRzPoQwLkqvMikS6kHKumIchsQYT0XOF0ugaMA/LNora7+S/78nmu//iDG+a/ceQhFSe6B1fWoI4ecQwgo5aHU4GoHkLDsNObfshkW5A8QYf4ox/lqsk4RfaVePcePjpg8hHBiUyna4SDzhx46K/FsoxnhWSrOj7ZHOA9v7/4f42HuQonrsXLQBhBAmR5FkZXn/RCTnX2LyTdqXyZHssHVjqR1lrIrqLf4T2CqEMEVxIyoF2pnAVsgB6XVgJlsvuyFe5dao6DpHHSS8z37ISfDJWEu7+ARyJCWEMAma7+/EGL+w+xMh49jg4lqsSITicDAQzakbkAOOwzHGw402DkcefIuYsfOQZ/LDIYTjEVNzbIzxPVPAFIqIbshjtCeZlXOdBQlz/DBKpzKPfS4EwquQ19ATyEhzM4qCOhOlktqxgeQ6hJORd9otIYQFoBZGHUKYGhkWvo4xPtoogkoC2c6JQHYCmi8nU3EDbEn5cSnwMnBGCGFJu3Y0qrtze4zxV1N+/hxjfKLRtHZ2xBj/MOXtpuiM6ArMaj+ngL9ypA8NIfRBadGGoGiCLEgUUrugaI0botVfq6ckj0rh0C2EME2M8ccY4ybIA/DbxlHduZCs4XORge+fMcZ/ADsgD9gA3BdCuL3Yo2KMz6HIrplQQecD4a9UdpVJoVEgUTRci/bVwciruphTfylGrQ+DY4xvmYGqaoqK74G+KCUlIYTutq5/iTFeiqINXgH+h7yQHY5OhyKlI0CM8VOU4upb4KYQwoL1vtPgvWkDpIy+M4TwN0vLWBeJzLZrCOEBc9wp7lVuP+3MiDH+ihwW+pE/jfU3SLZvSd5/H5op5ruh6IlVkENL5RFVY3QBFI1/AXBJCGGNJBX0GSjl+8NICX8/iiY9EUXM7tR4qjsGkrS3fYAjkQ7iv8kjk6GIaqJSbX8HLB5CmMNSz22IDDfP00EQY3wHpX07rFgfDseYDjfaOBwZEGP83RTLRyKh4GXkcRKA3wtjTazl9ZwF5Zt/LlqhNkeb4Unkqb4g1JSMpkB5N8a4DioWfwxiNldEKaFcwdjOqOOd+CLyxpwTuDKEcGYIYbEQwrpIIFoeq080nPzKbY3hCWTHxRjf70gGWFO2r4uMleeEEE5ChSLPQCkOqqb87JSIyt/8LyRwHYq86x4OIRyLolMA5kJK+VNijD/noBP+8kgOyDv0T5QGsEXvYrs+DopgXN7+hkfZjCZCCGsBi6LUMN+ChF+LntkCCfuLAO+FEE6zM+7LqNpanxb8RgdY3+eg9IyTonNghxDCuBZFFEOFal0MBy8hheKuFi062M6JwpD/J+JLtooxPpKNSoejjZHwQmPZev2LV4sxfoRqGPwCHFV47Id8taguRw4UQ1BNv6tDCAuU6UnOurmBLYHxYozfN5JQRw0hhLEQf/RmjPGtnLSMQN7/I5H3izNrRmS0vyrG+EwGkkcJMcZnY4wrI+e5gcDFwAEhhMVDCH3MGWl1FEFxFUp/tQKwucvTw0Wx15yN6g1eEWP8Bf7aF59DUblFrbwbUCTy7agG7KbAETHGnxsoF482LGrul9x0OBxVQZE70+FwZIQJJssiBdz8yJP0lBjj8+ZdcRBSRk/kRptRh3msDLPphRAeRAr0xVNljylThiSfB6Cc9M5gNhCWmuKnGOMg+7weSu0zM8p9C8oXfWGM8YyW3nM70zgAWBhFYC2DjDKbA9eX5tAcKGrrrhjjbo2ksTUwhWdTCGERVFB3arQfbRljHJRjbMd0mKA1B4pk2RgVLT8HpQJcMMY4ZUby/kII4WyUimr8Vjw7NvAxsGuM8cp2J24MgAnwSwD/izF+Y4rEkDgijIX4jC2QYuVb4O8xxotz0Tw6CCHshCJuegJXWns41tLwVXavCiH0Q6np5kQpBW+KMb5t98ZBSr1NgIWiF+B1dEKEEJ4DfkRe418Cd9utN1Faq1sR77FtykM1GravTodSeO6EIjcuBM5OvcBt3R6BUh/OFGN8qyxDOBoHU2KPHWP8LjctKTqrvJ/IDrOiWrDH2K2PUD2b64F3fT2MPGxMX0Gp5E6PtQwTf0e8wkoxxheT5+e0678Bj0ZLY11lnsjhcAwfbrRxOCoCYzBnQMqUHVDqjLNQSOsl6KA+puW/4GgtQggHAo8Bz0TVXdgbhWnPFmN8M3luPJSSaHlUh2Q5YK0Y470ZyB5jYKlthoYQFkJeQksiQfku4N8xxgdMAbk0ytXbEwn8PyWe1llqF3QmgSyEMBfwD+QRuFGM8TVn+vPB5vwyqObF0qiOx1oxxtuyEmYIIWyF0uutHGO8t/A+bsFQvijyxDwpKo2Xox2RrtsQwoTI43VzdK7tE2M8PSd9o4oQQl8UWbQNSs1yOTKUv5SVsOEgUW5Nj6LpFkQp7f6DvGZXR+fehTHGvXOeZw5He8DS9hyB0t3OgXi4AcAHKMXmg8BCqLbN6cChMcbfMvN2vYzWzZDh+3skN1wVY/w+hLAyiiC4Osa4c8HH5qDVUW10Nnm/JLNdjaLyb0JpfRdF/XwBRYs8GmN8LxuxHRAhhL2AU1G61MOAO4DxUKr24xAfPdgcvGK9PdJlN4ejY8ONNg5HxWCK3SLEfl2URubTGOPkOenqLDCl+stAd5R79yyUbugB4HDENC+B0qDNQS2S4yPg/hjjdo2meUxCotAagNKhDUEp7L5E9Rf+A2wRVdyy7ncbSW89dAaBzLxLI9qHTkeh9ru413d+BBVi3xwZ/g7KTU+BEMK0pgk9LwAAGdRJREFUaK1+BGwaYyzSpBVzqUil1gOtiyNRJEHW9CVjCspCewhhZpSq5EwT+Csn1JeMTX2AcYFusZTnPIQwO6rnsxhKIbJujPGpRtM7IiTKrb888EMIuyIP2oHIQP4bSnGyVW4nBIejvRBC6GnRuxOhmgvjI8eocZHBph8y5owL7FaViMBSVPWq6My7EBlbVwQmtH75unUMF51N3g8hFOnGd4kxvlEYEVAatJNQmvdrkDzxoKe/ah1CCFMi49euaG+8EcmVkyMnqY9LzxdydOV4OofDMWpwo43DUVGEEMZHCogdgFNjjA9kJqlTIChn/HzA+qjuyLdIKX0AtVoRII+WZ4FH7PePgB9ijIMbSvAYhoLJDCFcjpjTHWOMj4QQZkRGnEOBc2OMv4cQ+lc5WqWzCGQhhD2RwHUbsL4rIvLDoli6Vi3VRAhhXzRXXkVpn26NKgqcPrMscD7wVIxx88ZTOWajniBfVQVjonzYGNgOmA3Vu3gW2C/G+EHp+Q3QWT5vFZQViZFmIpQyZgsUEXQ/qlH4bPLsiqiI8E/Ae4XnrHvrOzobWqNMtEi0cdC63wTYOsZ4fVUUkSGEyZAyele0L3VD6T7P87RojpFBR5T36ziBTIkiRu+PMW5bfhZYCbgO6GOXJ48xftooejs6Smkat0N1Lh9AMrJHLjkcnRxutHE4KgxjdCaOMX6em5bOhsRbbheUzqoH8AwquP4IMtD8XvpOJYTFzg5L3/MfZCQ4LqqA4o2ISV0txvhJUE2M14HtYox3D+fPZUdHFMjKMCPawBjjirlpcVQblmf7aORxeTuqTXA3MAEymB+K0mYs4JFb+VD18ywxeMyDlEFvAHciRe4e9tgZyHgzjGGjSorTEMItwFLAO2hdLIZSQN0K3Butno3D0RmRrOU+wOyoSDwo3e3PpWf+MiCbDDQlOj8+RF7lldmzgorIzwBsBMwQY9wgM0mODoqOKO+XnQpCCC8ip4rFzfmuXBf2BlTD6pkY438aTnAngKVpnBtlctgW+AE5Sl0VY/w+I2kOh6Md4UYbh8MxRiOEMDlKybAxqhdxJXAa8EoVPY87K0ppcHqgFHb/jjEeHUJYBnkUrQfcbJ7Xi6OUFCfGGP+ZjfBWoiMKZCkszUHvQsHicAwPIYQFUSHaZe3SL8jDMiBF9ZkxxofzUOfoSAghPIzSZO4TY3zJIlJuQ4acZYGv7d6V+agcFokSemNU62lv4F8xxl9DCO+iyN6xUH76q1C6mK/zUexwtC9CCBcgPq4PMBilTjoKuDjG+GPp2ZQnPAjYHVghxvhKY6keMUII4wDEGH/y6DhHZ0YIYSpg1Rjjucm1HlH1YQuHnaNijEfYveIcHIBqZH4cY9y18ZR3Llia5IWopWl8Bo39gzHGQTlpczgcbY8uuQlwOByOnLBcsFcihcpRwPJIGXRUCGHSnLSNCQgh9Ie/al2EUKt/8TmwYghhPOAUpOh92Aw2RYq7fqhwc2EUqSyi0CENNgAxxqFusHG0FjHGp2OMy6OIgpNR/bATgdWAddxg42gNQggLA5MCV6A0paC0e3cC2yPD4ATAv0IIH1oEZiWQKG53Aq7FUgWGEHZCNTwWAg5GaWMOB860NKAOR6eBOXwQQtgU2Bq4HNWLXBMZ8U8Cng8hbFg8C+KZ7Hv9kUPV0CoabEDGmiJq1A02jk6O7YGzQwj/CSEsDxBj/NPunY/k6cNCCA+FEJY3g01/tN6XQNGmjtFEjPG7GONdwM4oXVpP4GbgVjPoOByOTgSPtHE4HA5DqQbJ+sAglC/2xpx0dVaEEI4CZgTOAZ5OGH9CCKsClyEGf07k2fWI3VscKYFfiTFuWPU0Pw6Hw+FoHVJP9RDCGsg7d22rbbYWKmS8UmH4CyE8D7wGvBZjPK5K54EZYa4A7okxHmbXvgBuQLV3BqNIm7mAAcBEMcbv8lDrcLQfQggvIyebQy3F7fYoqv1IVPNvfuAW4IwY4/+Vvrsh8FWM8aHGUu1wOFKEEGZA63VdYCrgXuCwIsWn1aLaDVgHGAi8hxzxJgdejDEulIHsTo0kTePmwDwxxhUyk+RwONoYbrRxOByOEpIaJAcCh8cY781MUqdECOFUYC/gI5Q+5uYY4/+S+0cAhwFDgbNR8em+9p2xgAVjjF+FihbRdjgcQpUU6Y6OhRDCTjHG8+3361BasfVjjJ+HECZGit6zgastErMy54FFiu4D3BhjfC6EsBWKLFg9xviUPXMBUmZfavR7eiVHp0IIYUm0Rk+OMV5h175CBs1DUdTZjchbvBswbozxl0zkOhyOESCEsBCq5bQSksvOBU4vasGGEFYAFgGmR8ab61H9tnfzUNz5EULoi3S7P1eppp/D4Rh9dMtNgMPhcFQNMcZvgFtCCE/EGL/KTU9nRYxxnxDCGcB5yNty9RDCxYix/yjGeEQI4U7gOOS5FVBazxuAC8xg4wouh6PicIONoyUURpYQwv4o7eXJMcb/FvcTg0034HtgziTV5AxIIdS9MNRUxWADEGP8NoRwmvEUIGeDocCfACGECYEJgVVijBfbd/w8c3R4WKrbYj3+hgwyr9u9PZH3/RUxxt+Ah0IIrwP3IeedX5y3cziqh8IYEGN8KoTwO0p1uABKVbqRnXeXxxjvCyE86Gu4cUgN3W6wcTg6F9xo43A4HC3ADTbtBxPog9UUWj2EsAxKk3Yhysn7L1TD5r/A8iGEuYCxUYqMN4u/4wKBw+FwdFyYwWYK4ATgV2DKEMK9qDj5x/CXYWdICOExYLsQwi3A8yiNaVOM8R95qBeKSDLzdJ0e+AMZaN5IDDYAnyAjzRr27FLIU3lL+zuViRJyOEYGyRoYDxi/4NPs+n9DCKvFGN+2ujUzAR+i9UAIYTK09n+OMb4Ezts5HFWG1WbbGmhC2Q/mRxFzZ4QQNkJZKp60Z90A63A4HKMBT4/mcDgcjmwwAb4pKTq7K4qsiaiWwfXAM2m9G3vO0y05HA5HJ0AIYX7gMRRJ+R4wPvAqOgOuTlKuTIAURGsh48gjwDExxodzpANJFNX9gOWBE4GpkSLrS+Al4F8xxmvs+W4osnRbVM9mMHBLjHHTRtLtcLQXzOFmHcTHnVUvzVkI4Thgf2ByS3O4FUqftmmM8Rbn7xyO6iKEMBbwKfBv4LgY4xd2fXZ0tu2KIkovRpGzH2Qi1eFwODoF3GjjcDgcjoYjSYlTKL3+UriFEHqiArU7Ae8DFwG3xhjfyEiyw+FwONoJIYSVgAOAp5DX/U4oV/59wCVFbTkz9E8HDAG+izF+n4fiGkIIJyGv49eA/wLfAssCS9sjtwJHxRhfsOfnBFYG/g94Ncb4o3sjOzoDzAN/U2BW4B3gjBjjlaVnZgBuByZFyt9JgcdjjCs2mFyHwzGSsMwIdwG7xBgvDSH0SB3rLNXpocAg5Lwwh59tDofDMepwo43D4XA4siIx3HQFusUYB9n1GYDzkeLrSeAy4B/O/DscDkfnQgihN3AYsD2wCfAESpm2MfAjMnxcVhg+cqMwspiS+mAUFbpPGiEQQlgC1WtbEnga2CvG+FQWgh2OBiGEMBEyuq6PDDIPAyfFGB+3+90QX7c0MA9wL3CNRd248dLhqDBCCDMDr6Aom8OS6z1ijH9aisQ3gOuAm2KMD2Yi1eFwODoF3GjjcDgcjnZHElmzMcrhfxsqxvxijPGjEEKvIgVOne+uCVwDXB5j3LlxVDscDoejvZGmQwohHA9sBWwXY7zdvHoPARZEnvtXAlfGGD/PTW8IoQ+KFPgXcHyhdAZiWpsmhHAgcDSKLlgXyV+umHZ0KoQQAprbTfZ5ZuABlO7we+BGZLz50O53jzEOzkWvw+EYeYQQugPXomjSLYF7Y4y/JfenBi4Hjo0x3p+FSIfD4ehEcKONw+FwOBqCEEIP4HNgAPA78A0wLvA68DYqSnsfMuY8bR5bqTKve4xxsBdrdjgcjs6FIkVmCGEKlB5zLmClGOM7dn9rVM9mZuSZv2aja9gktBZRNpcBSwDrxBhfbuk5+/0slOt/8SLiwOHojEh4tRWBO4CjgIVRofJvgEtR2rRBGcl0OBwjicRhYSkUSTMEOAO4B6X6HBpC2Ac4Hlguxvh/uWh1OByOzgI32jgcDoejIbCQ+dOR0m0vlO94ahR5MwUwEcqD/jHQG3gc1bT5FjgW6OLeyQ6Hw9FxkRg8VgV6Aj/EGB8KIfSJMf5qz4wN3ABMC2xdKH4ssuV44OUY4yU5DfghhFlRipgDgNNHZEAKIcwFPA8cGmM8tv0pdDjaF6lTTZ17XVBk3H9ijNuYd/52KIpuBuBl4MJyvRuHw9ExEEKYFjgL1Wf7EBlkBwBTorRoG2Qkz+FwODoN3GjjcDgcjoYhhDAlcAswFrB2jPENu94XmB54Bnlmvg8sBswJfBxjnC4LwQ6Hw+FoU4QQZkNK229RZGUP4D/IkP8g8D+k2N0CKYP2jTH+VOfvtKg0bm+EEPYCTkW0Hgrcn6aISZ4rUoNOALwL/D3GeHZO2h2OtkIIYXrgb8ClMcavk+uHIOecZYBXkpRpUwA7WHsvxrhA46l2OBytQeJkMQGqzTYrcrZ4NMZ4txljl0a16CZHhpvbgGtjjD9kItvhcDg6Fdxo43A4HI6GIAmrnwIVbf4S2C3Jb/5PlGpmtRjjq3ZtTuSJ/WGRPicX/Q6Hw+EYfYQQ9kBRl0OBi5BhZl5gbGBx4GtkzJnBvrJWjPG2KhUpNweERVHKs4WQouo44NlSPZvi3FsZOBvl+b88B80OR1vDjDNHAc8CJwE3oxo276H1cJKlSusKNCXpbhcDfowxvlKlde1wOITE4aAfcCewAPCLtcmA84C9Y4x/2vP9gJ89fbXD4XC0LbrlJsDhcDgcYwYKYT3G+FEI4URUqPIkYIMQwnzApsD+KKVGoex6Kfm+G2wcDoej4+NW5JG7FbATqnFxEvAW8AewIjLgzAJ0B14DqJJi1xwJPkbK6rVQP/4DXBhCODvG+L49F0MIYwFzo7SfD0DeKCGHow1xOTLQ7IpqXNyA1u77wL9ijIOhtnYLRXCM8bHiD1RpXTscjmFwLjAxsEOM8fIQwnrAtWiNB/irjtWPGWl0OByOTguPtHE4HA5HFoQQVkPKuuuARYDBwMYxxveyEuZwOByOdoV53k8PrAHshnLhXwKcEmP8JHmu8hGWIYRewBzAZiil2/fAicBVMcbvQwhzoLSgd8YYd8tZi8fhaGtY/ZrpkPFyO1SL6gFgR+fnHI6OC6tb8wyqK3pRjPGXEMLVqDbp6jHGjy3C5iDgrBjjZxnJdTgcjk4JN9o4HA6Ho6FI0sX0QrUADrRbK8QYH8hImsPhcDgaiMTgsbm1H5DB4+oY47cZSRtphBAGAAsDOwKrAk+hNHCLAtsC48cYB7nRxtEZYWt5blTjZlu0lk/CjJcZSXM4HMNBS5GfIYR5UWTsTjHG20MIyyCD7PrATZY+bXPgYGDTGOOzDSXc4XA4xgB0yU2Aw+FwOMYsJGnSfo8xHgwcCfwKLB5CCFmJczgcDkfDYOfA08AhwAbAC8CZwB0hhFVCCD2zEjgSiDF+H2O8C9gZRRz0Aq4C9gAONoNNNzfYODojbC0/gbzyNwJeAs4C7upoa9nhGJOQ1JpaMYTQO7n1PdAPmNQ+n47qtz1oBpueqL4NwHeNotfhcDjGJHikjcPhcDiyIClyOTlwBrAEsEuM8bq8lDkcDocjB0IIkwEroBoZs6I6MRvHGDuUQiiE0A2YAdgYmD7GuEFmkhyOhqKzrGWHozMjhNA1xjg0hLAripBbL8b4tt3rCVwPTAPcBOwNLBdjfMruzwv8A3ghxrh5DvodDoejs8ONNg6Hw+HIjhDCxNRq26wYY3wwM0kOh8PhyIDE4LE5ME+McYXMJI0yQgjjAMQYfyqUY7lpcjgahc60lh2OzoYkXXU3FFVzJXBAjPGn5JmpUIq02YEXUWq0r4GpUVTdIsBMMcYvG0u9w+FwjBlwo43D4XA4KoEQwizAI8jL6+HM5DgcDocjI0IIfZGs8rOlFRuSmyaHwzHy8LXscFQPScaDc4HVgTVjjC8k9xeOMT4ZQlgE2BqlMB2CUloPBF4GTosx/isD+Q6HwzFGwI02DofD4agMQggDYozft1QU0+FwOBwOh8PhcDgco4YkymZa4G1gX+DcGOMgu38gcBwwVYzxoxDCQGAuYB5gKuB54LYY4yc56Hc4HI4xBW60cTgcDofD4XA4HA6Hw+FwOMYQhBAeBCYDVo0xvmPX+iNDzoXAMTHGP/JR6HA4HGM2uuQmwOFwOBwOh8PhcDgcDofD4XC0P0IIkwNTovo0u1j9GoATgR+BSwuDTQgh2E/XHzocDkcD4ZE2DofD4XA4HA6Hw+FwOBwOxxiAEEIvYD7gb8A2wLfA1cA+wA4xxsvtOU9Z7XA4HJnQLTcBDofD4XA4HA6Hw+FwOBwOh6P9EWP8HXg0hPA/4D5gR2A3IAB/hBC6xRiHuMHG4XA48sEjbRwOh8PhcDgcDofD4XA4HI4xECGEKYBlgR2A+YFrgZOBF91w43A4HHngRhuHw+FwOBwOh8PhcDgcDodjDEUIoTswA0qZtgPQFzgbOD/G+GlO2hwOh2NMhBttHA6Hw+FwOBwOh8PhcDgcjjEcIYQ+wNzAlsD6wB/ATjHGG3PS5XA4HGMavKaNw+FwOBwOh8PhcDgcDofDMYYjxvgr8FgI4Q3gDuBA4Je8VDkcDseYB4+0cTgcDofD4XA4HA6Hw+FwOBzNEEKYMMb4VW46HA6HY0yDG20cDofD4XA4HA6Hw+FwOBwOh8PhcDgqgC65CXA4HA6Hw+FwOBwOh8PhcDgcDofD4XC40cbhcDgcDofD4XA4HA6Hw+FwOBwOh6MScKONw+FwOBwOh8PhcDgcDofD4XA4HA5HBeBGG4fD4XA4HA6Hw+FwOBwOh8PhcDgcjgrAjTYOh8PhcDgcDofD4XA4HA6Hw+FwOBwVgBttHA6Hw+FwOBwOh8PhcDgcDofD4XA4KgA32jgcDofD4XA4HA6Hw+FwOBwOh8PhcFQAbrRxOBwOh8PhcDgcjgYghPCPEMIHuelwOBwOh8PhcDgc1YUbbRwOh8PhcDgcDoejhBDCziGEGEJ4eiS/NzCEcEQIYa42omMW+3tTtcXfczgcDofD4XA4HNWGG20cDofD4XA4HA6HY1hsAnwALBBCmG4kvjcQOByYq8697YAZR5KOWezvTTWS33M4HA6Hw+FwOBwdEG60cTgcDofD4XA4HI4EIYSpgUWAvYGvkQFnRN/pFkLoMbxnYoyDY4yD2oZKh8PhcDgcDofD0RnhRhuHw+FwOBwOh8PhaI5NgO+BO4EbKBltQghTWeq0fUMIe4YQ3gUGATsD/7XHLrdnYghhS/veMDVtQggbhhCeCyH8HEL4KYTwSghhD7u3JXC9Pfqf5O8t1Q59djgcDofD4XA4HBVAt9wEOBwOh8PhcDgcDkfFsAlwU4zxzxDC1cBOIYT5Y4z/LT23FTAWcBEy2twMjA0cZdceteeeqPdPQgjLA1cDDwIH2OWZgUWBM4H/A84CdgeOA163Z17H4XA4HA6Hw+FwdEq40cbhcDgcDofD4XA4DCGEeYGZgN3s0mPAJ8iQUzbaTAZMF2P8Ovn+3cho82SM8coR/LtVgZ+AFWOMQ8s3Y4zvhRAeRUab+2OMD498jxwOh8PhcDgcDkdHgqdHczgcDofD4XA4HI4aNgG+BP4DEGOMwLXAhiGErqVnb0wNNqOAH4A+wPKj8TccDofD4XA4HA5HJ4IbbRwOh8PhcDgcDocDMKPMhshgM3UIYboQwnTA08BEwLKlr7w/mv/yPOAt4O4QwichhMtCCCuN5t90OBwOh8PhcDgcHRhutHE4HA6Hw+FwOBwOYRlgEmS4eTtp19n9TUrP/z46/yzG+BUwF7AGcBuwNDLg/HN0/q7D4XA4HA6Hw+HouPCaNg6Hw+FwOBwOh8MhbAJ8BexS5946wNohhB1H8DfiyPzDGOOfwO3A7SGELij6ZocQwtExxndG9u85HA6Hw+FwOByOjg032jgcDofD4XA4HI4xHiGEXsgwc32M8YY69z8DNkJRMU8P50/9aj/7t+J/jhdj/Lb4HGNsCiG8bB97juzfczgcDofD4XA4HB0fbrRxOBwOh8PhcDgcDhljxkZpyurhKeBrFI0zPKPNu8APwI4hhJ+R0eXpGGO9+jeXhBDGBR4CPgGmBHYDXgRet2deBIYCB4QQ+gGDgIcstZrD4XA4HA6Hw+HoZPCaNg6Hw+FwOBwOh8MhY8wfwP31bsYYm4A7gZWA8Vr6IzHGwcAWyNByAXA1sGQLj19p/3NnlBZtC+BaYGX7f8QYvwB2BCYELrW/N8vIdc3hcDgcDofD4XB0FIQYPUWyw+FwOBwOh8PhcDgcDofD4XA4HA5HbnikjcPhcDgcDofD4XA4HA6Hw+FwOBwORwXgRhuHw+FwOBwOh8PhcDgcDofD4XA4HI4KwI02DofD4XA4HA6Hw+FwOBwOh8PhcDgcFYAbbRwOh8PhcDgcDofD4XA4HA6Hw+FwOCoAN9o4HA6Hw+FwOBwOh8PhcDgcDofD4XBUAG60cTgcDofD4XA4HA6Hw+FwOBwOh8PhqADcaONwOBwOh8PhcDgcDofD4XA4HA6Hw1EBuNHG4XA4HA6Hw+FwOBwOh8PhcDgcDoejAnCjjcPhcDgcDofD4XA4HA6Hw+FwOBwORwXgRhuHw+FwOBwOh8PhcDgcDofD4XA4HI4KwI02DofD4XA4HA6Hw+FwOBwOh8PhcDgcFYAbbRwOh8PhcDgcDofD4XA4HA6Hw+FwOCqA/wf47XFpvmccVwAAAABJRU5ErkJggg==", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -956,6 +1337,47 @@ ")\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "low_dvl = df.iloc[:30]\n", + "ax = plot_shapley(\n", + " low_dvl,\n", + " title=\"Artists with low values\",\n", + " xlabel=\"Artist\",\n", + " ylabel=\"MSR Banzhaf value\",\n", + ")\n", + "plt.show()" + ] } ], "metadata": { diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index eaf5adcf0..8181cf450 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -222,9 +222,19 @@ def compute_values(self) -> np.ndarray: self.point_in_subset > 0, points_not_in_subset > 0 ) values: np.ndarray = ( - np.divide(1, self.point_in_subset, where=feasibility_map) + np.divide( + 1, + self.point_in_subset, + out=np.zeros_like(self.point_in_subset), + where=feasibility_map, + ) * self.positive_sums - + np.divide(1, points_not_in_subset, where=feasibility_map) + - np.divide( + 1, + points_not_in_subset, + out=np.zeros_like(self.point_in_subset), + where=feasibility_map, + ) * self.negative_sums ) return values @@ -249,7 +259,6 @@ def __call__( A collection of marginals. Each marginal is a tuple with index and its marginal utility. """ - log.debug("MSR Future Processor called") marginals: List[MarginalT] = [] for s, evaluation in future_result: previous_values = self.compute_values() @@ -365,8 +374,8 @@ def compute_generic_semivalues( processed_future = future_processor(future.result()) for idx, marginal_val in processed_future: result.update(idx, marginal_val) - if done(result): - return result + if done(result): + return result # Ensure that we always have n_submitted_jobs running try: diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index ab80066d7..724f6089d 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -668,7 +668,7 @@ def _check(self, r: ValuationResult) -> Status: corr = spearmanr(self._memory, r.values)[0] self._memory = r.values.copy() - self._completion = min(self.rtol / np.abs(corr - self._corr), 1.0) + self._update_completion(corr) if ( np.isclose(corr, self._corr, rtol=self.rtol) and self._iterations > self.min_iterations @@ -678,9 +678,18 @@ def _check(self, r: ValuationResult) -> Status: f"RankStability has converged with {corr=} in iteration {self._iterations}" ) return Status.Converged - self._corr = corr + self._corr = np.nan_to_num(corr, 0.0) return Status.Pending + def _update_completion(self, corr: float) -> None: + if np.isnan(corr): + self._completion = 0.0 + elif not np.isclose(corr, self._corr, rtol=self.rtol): + self._completion = corr + # self.rtol / np.abs(corr - self._corr) might be another option + else: + self._completion = 1.0 + def completion(self) -> float: return self._completion From 7e7286c30439360a086f5c49dcaa787640511010 Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Wed, 27 Mar 2024 14:01:06 +0100 Subject: [PATCH 09/42] chore and documentation tasks --- notebooks/msr_banzhaf_spotify.ipynb | 719 ++++++++++------------------ src/pydvl/value/sampler.py | 6 +- src/pydvl/value/semivalues.py | 15 +- 3 files changed, 260 insertions(+), 480 deletions(-) diff --git a/notebooks/msr_banzhaf_spotify.ipynb b/notebooks/msr_banzhaf_spotify.ipynb index 4c5be9b4c..a303651de 100644 --- a/notebooks/msr_banzhaf_spotify.ipynb +++ b/notebooks/msr_banzhaf_spotify.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Maximum Sample Reuse Banzhaf Values for data valuation" + "# Banzhaf Values for data valuation" ] }, { @@ -41,43 +41,26 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 1, "metadata": { "tags": [ "hide" ] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "%load_ext autoreload" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 2, "metadata": { "tags": [ "hide" ] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:matplotlib.pyplot:Loaded backend module://matplotlib_inline.backend_inline version unknown.\n" - ] - } - ], + "outputs": [], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -106,12 +89,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We will be using the following functions from pyDVL. The main entry point is the function [compute_shapley_values()](../../api/pydvl/value/shapley/common/#pydvl.value.shapley.common.compute_shapley_values), which provides a facade to all Shapley methods. In order to use it we need the classes [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset), [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility) and [Scorer](../../api/pydvl/utils/score/#pydvl.utils.score.Scorer)." + "We will be using the following functions from pyDVL. The main entry point is the function `compute_banzhaf_semivalues()`.\n", + "In order to use it we need the classes [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset), [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility) and [Scorer](../../api/pydvl/utils/score/#pydvl.utils.score.Scorer)." ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -133,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 4, "metadata": { "editable": true, "slideshow": { @@ -150,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 5, "metadata": { "editable": true, "slideshow": { @@ -173,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -347,178 +331,6 @@ "execution_count": 6, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
artistsongduration_msexplicityeardanceabilityenergykeyloudnessmodespeechinessacousticnessinstrumentalnesslivenessvalencetempogenre
1561Fetty Wap679 (feat. Remy Boyz)196693True20150.6180.7177-5.73810.31800.002560.0000000.62500.603190.0508
1410Meghan TrainorAll About That Bass187920True20150.8070.8879-3.72610.05030.057300.0000030.12400.961134.05214
1772Katy PerryChained To The Rhythm237733False20170.5620.8000-5.40410.11200.081400.0000000.19900.47195.02914
1670SigalaSweet Lovin' - Radio Edit202149False20150.6830.91010-1.23110.05150.055300.0000050.33600.674124.97715
1780Liam PayneStrip That Down204502False20170.8690.4856-5.59510.05450.246000.0000000.07650.527106.02814
\n", - "
" - ], - "text/plain": [ - " artist song duration_ms explicit year \\\n", - "1561 Fetty Wap 679 (feat. Remy Boyz) 196693 True 2015 \n", - "1410 Meghan Trainor All About That Bass 187920 True 2015 \n", - "1772 Katy Perry Chained To The Rhythm 237733 False 2017 \n", - "1670 Sigala Sweet Lovin' - Radio Edit 202149 False 2015 \n", - "1780 Liam Payne Strip That Down 204502 False 2017 \n", - "\n", - " danceability energy key loudness mode speechiness acousticness \\\n", - "1561 0.618 0.717 7 -5.738 1 0.3180 0.00256 \n", - "1410 0.807 0.887 9 -3.726 1 0.0503 0.05730 \n", - "1772 0.562 0.800 0 -5.404 1 0.1120 0.08140 \n", - "1670 0.683 0.910 10 -1.231 1 0.0515 0.05530 \n", - "1780 0.869 0.485 6 -5.595 1 0.0545 0.24600 \n", - "\n", - " instrumentalness liveness valence tempo genre \n", - "1561 0.000000 0.6250 0.603 190.050 8 \n", - "1410 0.000003 0.1240 0.961 134.052 14 \n", - "1772 0.000000 0.1990 0.471 95.029 14 \n", - "1670 0.000005 0.3360 0.674 124.977 15 \n", - "1780 0.000000 0.0765 0.527 106.028 14 " - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -536,7 +348,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -556,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -574,7 +386,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -598,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -607,9 +419,6 @@ "text": [ "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", - " warnings.warn(\n", - "WARNING:pydvl.value.semivalues:PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", " warnings.warn(\n" ] } @@ -641,7 +450,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -671,29 +480,29 @@ " \n", " \n", " \n", - " Kendrick Lamar\n", - " -0.885800\n", - " 0.179126\n", + " 5 Seconds of Summer\n", + " -0.581937\n", + " 0.101380\n", " \n", " \n", - " Alessia Cara\n", - " -0.752220\n", - " 0.090328\n", + " Shawn Mendes\n", + " -0.552785\n", + " 0.166859\n", " \n", " \n", - " Ava Max\n", - " -0.728605\n", - " 0.141735\n", + " Alessia Cara\n", + " -0.545159\n", + " 0.054849\n", " \n", " \n", - " 5 Seconds of Summer\n", - " -0.502302\n", - " 0.032807\n", + " Liam Payne\n", + " -0.405800\n", + " 0.262284\n", " \n", " \n", - " ZAYN\n", - " -0.426648\n", - " 0.137434\n", + " Kendrick Lamar\n", + " -0.405719\n", + " 0.240342\n", " \n", " \n", "\n", @@ -701,84 +510,16 @@ ], "text/plain": [ " data_value data_value_stderr\n", - "Kendrick Lamar -0.885800 0.179126\n", - "Alessia Cara -0.752220 0.090328\n", - "Ava Max -0.728605 0.141735\n", - "5 Seconds of Summer -0.502302 0.032807\n", - "ZAYN -0.426648 0.137434" + "5 Seconds of Summer -0.581937 0.101380\n", + "Shawn Mendes -0.552785 0.166859\n", + "Alessia Cara -0.545159 0.054849\n", + "Liam Payne -0.405800 0.262284\n", + "Kendrick Lamar -0.405719 0.240342" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
data_valuedata_value_stderr
Jonas Blue-0.7150330.047940
Major Lazer-0.6576950.111218
Years & Years-0.5468370.078450
Justin Bieber-0.5035730.054793
Liam Payne-0.4891800.117529
\n", - "
" - ], - "text/plain": [ - " data_value data_value_stderr\n", - "Jonas Blue -0.715033 0.047940\n", - "Major Lazer -0.657695 0.111218\n", - "Years & Years -0.546837 0.078450\n", - "Justin Bieber -0.503573 0.054793\n", - "Liam Payne -0.489180 0.117529" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -794,7 +535,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 12, "metadata": { "editable": true, "slideshow": { @@ -808,19 +549,7 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABm0AAALBCAYAAAC6DOWpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5hkVZn48e87pFGiShqSjQkxoWBYRBTEhGNkMWGOmGFR1sYEqLu0cZFVWUAXDBiRtLaABFEcERQF9SdmWxkZkkgQHJCZ8/vjnHLu1FR3V3dXdd1b8/08z326bqhb771VfcN57zknUkpIkiRJkiRJkiRpsBYMOgBJkiRJkiRJkiSZtJEkSZIkSZIkSaoFkzaSJEmSJEmSJEk1YNJGkiRJkiRJkiSpBkzaSJIkSZIkSZIk1YBJG0mSJEmSJEmSpBowaSNJkiRJkiRJklQDJm0kSZIkSZIkSZJqwKSNJEmSJEmSJElSDZi0kSRJktRRROwVESkijhh0LP0SEa8o2/iKGb4vRcSFPYphIiImerGuJoqIkbI/Txp0LJIkSdKgmbSRJEmSGiYi3lUKuVNE7DSH9fS1sHy2CZE6WNsTKZIkSZIGY91BByBJkiSpexERwGuABATwWuDtffq4S4GdgRv6tP46OA34AbBs0IFIkiRJkjVtJEmSpGZ5CjACfBa4Bnh5RKzfjw9KKd2eUvplSmlokzYppZvLNt486FgkSZIkyaSNJEmS1CyvLX9PAE4GNgee22nBiDiiNE+2V0QcEBGXRMTfStNfRwB/KIu+vNLc2j+bM5usT5uIuE9EHB8Rv42Iv0fEjRHxs4j4n4i4V1nmQuDE8pYT29Y/UpbZOCLeExE/j4hbIuLWiPhdRHwlInabbkdExJfK+u7fNv2zZfr5bdM3joh/RMR3K9NWa8Kttc3AvYF7t8V9UocYNi/7YllE3BER/y8iXjld7N2IiA0iYrTs29vLProoIp7fttxGEXFnRCxpm363iFheYn9p27w3lOmvmiaG0bLcQZPM3yYi7oqIH7VNe29ELImIa0psV0fEFyPiQTPY/gvLd9Fp3qRN70XEdhHxiYj4fflO/hIRZ0bEozosO6ffoCRJktRrNo8mSZIkNUREbAU8C/h1Sun7EXEL8DbgdcBXpnjr24AnA/8HfBvYFLgQ2Aw4CLgCOL2y/OVTxLAI+CGwCfBN4OvAQmBH4KXAJ4C/ACcBNwHPBs5oW+dNpZm3s4HHAhcDnwbuArYD9gYuAi6bYpsAzgdeCOwD/KYyfZ/y97ERsTCltLyMP4F8D7RaMqfNBHAkcHAZP7oy7/LVF2UzYAlwJ3AKsAHwPOB/I2JlSumz08Q/qVJ76pwS8y+BTwJ3B/YHvhIRD08pvRMgpfS3iLgUeExEbJxSurWsZo8SE+R98vnKR7T20VT7gvKe/wBeBny8w/yXAOuQv++WxwOj5N/a14G/AfcvsT8rIvZIKV0xzefOSkTsCnwLuCd5/51KTmw+B/heRDw3pfTNsmwvfoOSJElST5m0kSRJkprjlcB6lALylNLPI+IyYO+IuF9K6beTvO+JwO4ppZ9UJ0bEBDlpc3lK6YguY9ifXCB+cEpptUL8iNgQWFliOymXifNs4PSU0kltyz6UXFh+ekrpuW3zFpATS9O5oPzdB/if8t6dgG2Bc8mJqj1YlZjYp+19a0gpTQBHtGpwTLNfdgE+AxyYUlpRPv9o4KfAO8hN2M3W28gJm7OAZ6WU7irrP5Lc19BhEfGNlNL3y/IXkLf18cB4mbYPsAL4Dqu2vbV/9wZ+n1L641RBpJT+HBHnAU+JiIeklH7etsjLyUmrL1WmXQBsVUketT53F3KSawzYd/pdMDMRsS7wVWAjYO+U0ncq87YhJxs/ExEjKaU7gIcw99+gJEmS1FM2jyZJkiQ1QKkV8BpyUuRzlVknAcGqZtM6Ob49YdMDf2+fkFK6LaW0xvRZrGdlSumv070xpfR7cs2Yvcv+gVXJifeSExb7VN6yD3Ab8IMZxjiZ24FDWgmbEtMvyImJnSNiozms+1VAKuu/q7L+64D3l9HXVJZvT0y1Xl9Grm2yXUQ8oEx/ODnxNl0tm5ZW8unl1YkR8UjgQcB4Sukv1RjbEzZl+hXkhM7eEbFel589E4uB+wL/XU3YlM++GvgQsDWr7yOYw29QkiRJ6jWTNpIkSVIzPJFcIH1uSunPlelfJNd0eMUUBeGX9jCOM8nNXX0yIr4eEa+LiAdXkibd+gW5ubEXlb5P/j0iHluaBZuJC4B7kRMRkPfTspTSD8gJi30AImILcs2K76WU/jHDz5jMb1JKt3SYflX5e4/ZrDQiNgbuB1ydUvplh0VaNYUeUZl2MTn50NreTYFdyYmZao0kyPuoup7pnAbcDLw4ItapTG8lcU7qsA2LI+L/Sl8//2j1CwQ8k9xk2+ZdfvZM7F7+3jtyf06rDcCjy/ydy99e/QYlSZKknjFpI0mSJDXD68rfk6oTU0o3kvuq2ZLcFFkn1/QqiNKc1qPJtTeeBBwH/Bz4Y0S8dQbrWUFOHhwN7AB8kFxD5YaI+O8Z1FL5Zw2TSrNf51fm7VYSGE8k10jqtnZJN26aZHqrZsw6k8yfTqtZrmWTzG9N36w1IaV0J/A94KElQbVX+fzzU0pXlve0kjb7kGvxdJW0KbWnvgosAp4C/+xz50XA9eQm3P4pIg4CvkFuru275O/4feS+glp92WxA792r/H0ecHiH4YAyfyPo6W9QkiRJ6hmTNpIkSVLNlUL455TRL7VqLVRqL/xrmfe6jivIBfQ9k1K6MqX0AnIh+SPJnc4vAD4eEa+ewXr+mlL6t5TS9uSO6l8D/BJ4M3Bsl6tpJR6exJrNfl1ATlzsTRf92dTIzeXv1pPMX9S2XMsF5MTUPmVYTk5CtObtHREbAHsC/680tdat9ibSFpO//y9Way6VfmWOICcKH5xSekFK6dCU0uGlf6BrZ/CZKyvrbLdZh2mt/fHslFJMMRzZekOPfoOSJElSz3S6+JUkSZJULy8H1ic393X5JMs8C3hSROyYUvpDl+tt9cUyqxohpa+Vy4DLIuL75FoVzwE+M9P1p5R+C/w2Ir4IXMfktYba33dNRPyCnIh4WpncStosAe4gJzCeCPwV6LZvnxXkfT7vUkq3RsTvgPtExP1TSr9pW2Tv8vfHbdOr/drsDnw/pbS8Mu/FwBuADZlhjaOU0pKI+A3w7FJzqZW8+WzbopuTEyqnppRWqylUaq7sOoOPbfUpsz3Q/pt+ZIflW30V7Uluxm9GZvsblCRJknrJmjaSJElS/b22/H1jSuk1nQZyM2XB6p3TT+ev5Fo4O3T7hohoNTfWbqvy9/bKtFbn9GusPyJ2jIj7dFjPPchNZ63ROfwULgDuDhxE7mfmKvhns14XA88n9wd0YUppZZfr/AuwRUTcbQZx9NL/kr/PD1f7kYmIzYH3VJap+jG5tsmzgQezemKmVcPosLbxmfgssBB4I/B04KcppfYk2HXk38Bu1ebFSn9LH2dmfdm0+mJ6bXViROxDbpqt3RnA74A3RcTTO60wInaPiLuX1738DUqSJEk9YU0bSZIkqcYiYi/gAcDPUkqXTrHoZ4B3Aa+MiMNLLZgppZT+FhGXAHtGxMnAr8k1TM5MKf10kre9FDgwIr5HLiD/Kzkh8kxyrZajK8teTC7APzgi7sWqvnX+G9gFODUifghcCVwNbEFOOKxH7l+kW+eTm7PaktzXTvu8vSqvZ7LORwFnR8R3ydt2RUrp/2awjrn4CLAveX9cERHfJCemnkfezg+llL5XfUNKaUVEXMiqGiLnV+b9sdTeuS/5O/7OLGL6PKv6plmPNWvZkFJaGRHHkJvM+1lEnEGusbQ3uem6b7OqptB0TgQOBQ6LiF2AX5D/F/YFTmNVs4Ctz/5HROwHnAOMl9pfl5N/g9uTv8/7kJuXu53e/gYlSZKknjBpI0mSJNVbq5bBp6daKKU0ERHnAU8mJ1BO63L9LwX+i9y02IvItTuWApMlbb5EroXwWGA34G7An4EvAx9NKf28EtNfI+JfyZ3Av4LcLBfAF4AfAWPAE8pn34Pcqf1lwDEppdU6t5/GheT+TxawZg2S84H3l9czqV3yAXIzX88E9iA38fZZYF6SNimlOyPiycAhwAHAW4C7gCuAg1NKX5rkreeTkw63kPdx+7z7ApellNr7w+kmpj9FxLfJza/dBZw8yaLvIX+XrwEOJNf+ORd4Nznh0+3nXRcRTwA+DDye/Fv5Efk3viNtSZvynp+WBM8hwDOAV5J/G8vITeMdDtxQFu/lb1CSJEnqiUipp32SSpIkSZIkSZIkaRbs00aSJEmSJEmSJKkGTNpIkiRJkiRJkiTVgEkbSZIkSZIkSZKkGjBpI0mSJEmSJEmSVAMmbSRJkiRJkiRJkmrApI0kSZIkSZIkSVINrDvoAIZRRASwDXDroGORJEmSJEmSJEm1sDFwdUopTbaASZv+2AZYOuggJEmSJEmSJElSrWwH/HmymSZt+qNVw2Y7rG0jSZIkSZIkSdLabmNyZY8pcwYmbfrr1pTSLYMOQpIkSZIkSZIkDU7uVWV6C/ochyRJkiRJkiRJkrpg0kaSJEmSJEmSJKkGTNpIkiRJkiRJkiTVgEkbSZIkSZIkSZKkGjBpI0mSJEmSJEmSVAMmbSRJkiRJkiRJkmqg8UmbiHhTRExExPKIuCQiHj3FshdGROowjFeWOanD/LPnZ2skSZIkSZIkSdLaat1BBzAXEfEC4GPA64FLgIOBcyJip5TSdR3esh+wfmX8XsAVwNfaljsbeGVl/I5exSxJkiRJkiRJktRJo5M2wCHACSmlEwEi4vXAYuBVwFj7wimlG6vjEfFC4HbWTNrckVK6ptsgImIDYIPKpI27fa8kSZIkSZIkSRI0uHm0iFgf2A04rzUtpbSyjO/e5WpeDXw5pXRb2/S9IuK6iPhVRBwbEfeaZj2HATdXhqVdfr4kSZIkSZIkSRLQ4KQNsDmwDnBt2/Rrga2ne3Pp++YhwKfbZp0NvAzYB3gH8ATgrIhYZ4rVHQVsWhm26yJ+SZIkSZIkSZKkf2p682hz8WrgZymlS6sTU0pfroz+LCJ+CvwO2As4v9OKUkp3UOn3JiJ6HqwkSZIkSZIkSRpuTa5pcwOwAtiqbfpWwJT90UTEhsALgc9M9yEppd+Xz7rf7MKUJEmSJEmSJEmaXmOTNimlO4HLyM2YARARC8r4xdO8/XnABsAXpvuciNgOuBewbNbBSpIkSZIkSZIkTaOxSZviY8BrI+LlEbEzcCywIXAiQER8LiKO6vC+VwOnp5T+Up0YERtFxIcj4l8iYiQi9gHOAH4LnNPXLZEkSZIkSZIkSWu1Rvdpk1L6SkRsAbwP2Bq4HHhaSunassgOwMrqeyJiJ+BxwFM6rHIF8DDg5cBmwNXAt4D3lH5rJEmSJEmSJEmS+iJSSoOOYehExCbAzcCmKaVbBh2PJEmSJEmSJEkanG7zBo2uaSNJkiSpv0ZGxxcBi+awimUTY4vtH1KSJEmSumDSRpIkSdJUDgQOn8P7jwSO6E0okiRJkjTcTNpIkiRJmspxwJkdpi8ElpTXewDLJ3m/tWwkSZIkqUv2adMH9mkjSZKkYTcyOr4h8LcyutHE2OLbBhmPJEmSJNVZt3mDBfMXkiRJkiRJkiRJkiZj0kaSJEmSJEmSJKkGTNpIkiRJkiRJkiTVgEkbSZIkSZIkSZKkGjBpI0mSJEmSJEmSVAMmbSRJkiRJkiRJkmrApI0kSZIkSZIkSVINmLSRJEmSJEmSJEmqAZM2kiRJkiRJkiRJNWDSRpIkSZIkSZIkqQZM2kiSJEmSJEmSJNWASRtJkiRJkiRJkqQaMGkjSZIkSZIkSZJUAyZtJEmSJEmSJEmSasCkjSRJkiRJkiRJUg2YtJEkSZIkSZIkSaoBkzaSJEmSJEmSJEk1YNJGkiRJkiRJkiSpBkzaSJIkSZIkSZIk1YBJG0mSJEmSJEmSpBowaSNJkiRJkiRJklQDJm0kSZIkSZIkSZJqwKSNJEmSJEmSJElSDZi0kSRJkiRJkiRJqgGTNpIkSZIkSZIkSTVg0kaSJEmSJEmSJKkGTNpIkiRJkiRJkiTVgEkbSZIkSZIkSZKkGjBpI0mSJEmSJEmSVAMmbSRJkiRJkiRJkmrApI0kSZIkSZIkSVINmLSRJEmSJEmSJEmqAZM2kiRJkiRJkiRJNWDSRpIkSZIkSZIkqQZM2kiSJEmSJEmSJNWASRtJkiRJkiRJkqQaMGkjSZIkSZIkSZJUAyZtJEmSJEmSJEmSasCkjSRJkiRJkiRJUg00PmkTEW+KiImIWB4Rl0TEo6dY9hURkdqG5W3LRES8LyKWRcTfI+K8iLh//7dEkiRJkiRJkiStzRqdtImIFwAfA44EdgWuAM6JiC2neNstwKLKcO+2+f8OvBV4PfAY4LayzoW9jV6SJEmSJEmSJGmVRidtgEOAE1JKJ6aUfkFOtNwOvGqK96SU0jWV4drWjIgI4GDgAymlM1JKPwVeBmwDPKdfGyFJkiRJkiRJktTYpE1ErA/sBpzXmpZSWlnGd5/irRtFxB8j4qqIOCMiHlyZtyOwdds6bwYumWqdEbFBRGzSGoCNZ7VRkiRJkiRJkiRprdXYpA2wObAOcG3b9GvJiZdOfkWuhfNs4CXk7f9+RGxX5rfeN5N1AhwG3FwZlnYRvyRJkiRJkiRJ0j81OWkzYymli1NKn0spXZ5S+g6wH3A9cOAcV30UsGll2G7qxSVJkiRJkiRJkla37qADmIMbgBXAVm3TtwKu6WYFKaV/RMRPgPuVSa33bQUsa1vn5VOs5w7gjtZ47hpHkiRJkiRJkiSpe42taZNSuhO4DNinNS0iFpTxi7tZR0SsAzyUVQmaP5ATN9V1bgI8ptt1SpIkSZIkSZIkzUaTa9oAfAz4bET8CLgUOBjYEDgRICI+B/w5pXRYGX8v8APgt8BmwKHAvYFPA6SUUkQcDbw7In5DTuK8H7gaOH2etkmSJEmSJEmSJK2FGp20SSl9JSK2AN4HbE1uwuxpKaVryyI7ACsrb7kHcEJZ9q/kmjqPTSn9orLMh8iJn+PJiZ3vlXUu79+WSJIkSZIkSZKktV2klAYdw9ApTardDGyaUrpl0PFIkiRJvTYyOr4h8LcyutHE2OLbBhmPJEmSJNVZt3mDxvZpI0mSJEmSJEmSNExM2kiSJEmSJEmSJNWASRtJkiRJkiRJkqQaMGkjSZIkSZIkSZJUAyZtJEmSJEmSJEmSasCkjSRJkiRJkiRJUg2YtJEkSZIkSZIkSaoBkzaSJEmSJEmSJEk1YNJGkiRJkiRJkiSpBkzaSJIkSZIkSZIk1YBJG0mSJEmSJEmSpBowaSNJkiRJkiRJklQDJm0kSZIkSZIkSZJqwKSNJEmSJEmSJElSDZi0kSRJkiRJkiRJqgGTNpIkSZIkSZIkSTVg0kaSJEmSJEmSJKkGTNpIkiRJkiRJkiTVgEkbSZIkSZIkSZKkGjBpI0mSJEmSJEmSVAMmbSRJkiRJkiRJkmrApI0kSZIkSZIkSVINmLSRJEmSJEmSJEmqAZM2kiRJkiRJkiRJNWDSRpIkSZIkSZIkqQZM2kiSJEmSJEmSJNXAuoMOQJIkSZIk9dfI6PgiYNEcVrFsYmzxsl7FI0mSpM5M2kiSJEmSNPwOBA6fw/uPBI7oTSiSJEmajEkbSZIkSZKG33HAmR2mLwSWlNd7AMsneb+1bCRJkuaBSRtJkiRJkoZcadpsjcTLyOj4hpXRKybGFt82f1FJkiSp3YJBByBJkiRJkiRJkiSTNpIkSZIkSZIkSbVg0kaSJEmSJEmSJKkGTNpIkiRJkiRJkiTVgEkbSZIkSZIkSZKkGjBpI0mSJEmSJEmSVAMmbSRJkiRJkiRJkmrApI0kSZIkSZIkSVINmLSRJEmSJEmSJEmqAZM2kiRJkiRJkiRJNWDSRpIkSZIkSZIkqQZM2kiSJEmSJEmSJNWASRtJkiRJkiRJkqQaaHzSJiLeFBETEbE8Ii6JiEdPsexrI+KiiPhrGc5rXz4iToqI1Dac3f8tkSRJkiRJkiRJa7NGJ20i4gXAx4AjgV2BK4BzImLLSd6yF/AlYG9gd+Aq4FsRsW3bcmcDiyrDi3oevCRJkiRJkiRJUkWjkzbAIcAJKaUTU0q/AF4P3A68qtPCKaUXp5Q+lVK6PKX0S+A15H2wT9uid6SUrqkMf+3nRkiSJEmSJEmSJDU2aRMR6wO7Aee1pqWUVpbx3btczd2B9YAb26bvFRHXRcSvIuLYiLjXNLFsEBGbtAZg4643RJIkSZIkSZIkiQYnbYDNgXWAa9umXwts3eU6PghcTSXxQ24a7WXk2jfvAJ4AnBUR60yxnsOAmyvD0i4/X5IkSZIkSZIkCYB1Bx3AoETEKPBCYK+U0vLW9JTSlyuL/Swifgr8jtwfzvmTrO4oct86LRtj4kaSJEmSJEmSJM1Ak2va3ACsALZqm74VcM1Ub4yItwOjwFNSSj+datmU0u/LZ91vimXuSCnd0hqAW7uIX5IkSZIkSZIk6Z8am7RJKd0JXEZuxgyAiFhQxi+e7H0R8e/Ae4CnpZR+NN3nRMR2wL2AZXONWZIkSZIkSZIkaTJNbx7tY8BnI+JHwKXAwcCGwIkAEfE54M8ppcPK+DuA9wEHABMR0er75m8ppb9FxEbA4cDXybV17gt8CPgtcM58bZQkSZIkSZIkSVr7NDppk1L6SkRsQU7EbA1cTq5Bc21ZZAdgZeUtbwDWB05pW9WRwBHk5tYeBrwc2Ay4GvgW8J6U0h192QhJkiRJkiRJkiQanrQBSCl9AvjEJPP2ahsfmWZdfwee2qvYJEmSJEmSJEmSutXYPm0kSZIkSZIkSZKGiUkbSZIkSZIkSZKkGjBpI0mSJEmSJEmSVAON79NGkiRJkiSp7kZGxxcBi+awimUTY4uX9SoeSZJUTyZtJEmSJEmS+u9A4PA5vP9I4IjehCJJkurKpI0kSZIkSVL/HQec2WH6QmBJeb0HsHyS91vLRpKktYBJG0mSJEmSpD4rTZutkXgZGR3fsDJ6xcTY4tvmLypJklQ3CwYdgCRJkiRJkiRJkkzaSJIkSZIkSZIk1YJJG0mSJEmSJEmSpBowaSNJkiRJkiRJklQDJm0kSZIkSZIkSZJqYN1BByBJkiRJkiRp+I2Mji8CFs1hFcsmxhYv61U8klRHJm0kSZIkSZIkzYcDgcPn8P4jgSN6E4ok1ZNJG0mSJEmSJEnz4TjgzA7TFwJLyus9gOWTvN9aNpKGnkkbSZIkSZIkSX1XmjZbI/EyMjq+YWX0iomxxbfNX1SSVC8LBh2AJEmSJEmSJEmSrGkjSerAziElSZIkSZKk+WfSRpLUiZ1DSpIkSZIkSfPMpI0kqRM7h5QkSZIkSZLmmUkbSdIa7BxSkiRJkiRJmn8LBh2AJEmSJEmSJEmSTNpIkiRJkiRJkiTVgs2jSZIkSZIkSZKkroyMji8CFs1hFctK0/zqwKSNJEmSpKHlDaUkSZLUcwcCh8/h/UcCR/QmlOFj0kaSJEnSMPOGUpIkSbUyBA8WHQec2WH6QmBJeb0HsHyS9/tQ1BRM2kiSJEkaZt5QSpIkqW4a/WBRSRitcZ08Mjq+YWX0iomxxbfNX1TDw6SNJEmSpKHlDaUkSZJqyAeLNCmTNpIkSZIkSZIkzRMfLNJUFgw6AEmSJEmSJEmSJJm0kSRJkiRJkiRJqgWTNpIkSZIkSZIkSTVg0kaSJEmSJEmSJKkGTNpIkiRJkiRJkiTVwLqDDkCSJEmSJGkqI6Pji4BFc1jFsomxxct6FY8kSVK/mLSRJEmSJEl1dyBw+BzefyRwRG9CkSRJ6h+TNpIkSZIkqe6OA87sMH0hsKS83gNYPsn7rWUjSUPC2pcadiZtJEmSJElSrZXCtTUK2EZGxzesjF4xMbb4tvmLSpI0INa+1FAzaSNJkiRJkiRJagprX2qombSRJEmSJEmSJDWCtS817BYMOgBJkiRJkiRJkiRZ00aSJEmSpCnZ4bEkSZLmi0kbSZIkSZKmZofHkiRJmheNbx4tIt4UERMRsTwiLomIR0+z/PMi4pdl+Z9FxNPb5kdEvC8ilkXE3yPivIi4f3+3QpIkSZJUY8cBu3UY9qgss8cky+xW3i9JkiRNq9E1bSLiBcDHgNcDlwAHA+dExE4ppes6LP9Y4EvAYcA3gAOA0yNi15TSz8ti/w68FXg58Afg/WWdD0opLe/zJkmSJEnSamyaa/Ds8FiSJEnzpdFJG+AQ4ISU0okAEfF6YDHwKmCsw/IHAWenlD5cxt8TEU8G3gy8PiKCnPj5QErpjLLOlwHXAs8Bvty/TZEkSZKkjmyaS5IkSVpLzDppExE7AO8E9ga2AJ6TUvpuRGwOvBc4MaX0k96E2fHz1ydXMz+qNS2ltDIizgN2n+Rtu5Nr5lSdQ07IAOwIbA2cV1nnzRFxSXlvx6RNRGwAbFCZtHHXGyJJkiRJUzsOOLPD9IXAkvJ6D2CylgGsZSNJkiQ1xKySNhHxIOAicp84lwD3a60rpXRDRDwO2BB4dY/i7GRzYB1yLZiqa4EHTvKerSdZfuvKfKZZppPDmNuTb5IkSZLUkU1zSZIkSWuPBbN834eAm4AHAC8Bom3+OLDn7MNqnKOATSvDdoMNR5IkSZIkSZIkNc1skzaPB45NKV0PpA7z/wRsO+uounMDsALYqm36VsA1k7znmmmWv6Yyrdt1klK6I6V0S2sAbp0mdkmSJEmSJEmSpNXMNmmzALh9ivlbAHfMct1dSSndCVwG7NOaFhELyvjFk7zt4uryxZMry/+BnJyprnMT4DFTrFOSJEmSJEmSJGnOZpu0+TGwuNOMiFgXeCHwg9kGNQMfA14bES+PiJ2BY8l96ZxYYvlcRBxVWf7jwNMi4m0R8cCIOAJ4JPAJgJRSAo4G3h0Rz4qIhwKfA64GTp+H7ZEkSZIkSZIkSWupdWf5vqOAb0TEscCXy7StIuJJwDuBnYE39yC+KaWUvhIRWwDvA7YGLgeellK6tiyyA7Cysvz3I+IA4APAfwK/AZ6TUvp5ZbUfIid+jgc2A75X1rm8v1sjSZIkSZIkSZLWZrNK2qSUzoqIV5BrrryuTP4CEMAtwMtSSt/tSYTTx/IJSk2ZDvP26jDta8DXplhfAt5bBkmSJEmSJEkCYGR0fBGwaA6rWDYxtnhZr+KRNHxmW9OGlNLnI+JU4CnA/chNrf0OOCeldGuP4pMkSZIkSZKkujgQOHwO7z8SOKI3oUgaRrNO2gCklG4DTutRLJIkSZIkSZJUZ8cBZ3aYvhBYUl7vAUzW1YK1bCRNaVZJm4jYoZvlUkp/ms36JUmSJEmSJKluStNmayReRkbHN6yMXjExtvi2+YuqezbvJtXfbGvaTACpi+XWmeX6JUmSJEmSJEm9ZfNuUs3NNmnzKtZM2qwDjAAvA64DPjn7sCRJkiRJkiRJPWbzblLNzSppk1I6abJ5EfFB4BJg01nGJEmSJEmSJEnqsaY37yatDRb0eoUppduAE4F/6/W6JUmSJEmSJEmShtVsm0ebzgJg6z6tW5IkSV2wk1FJkiRJkpqlp0mbiNgEeDxwKPCTXq5bkiRJM2Yno5IkSZIkNciskjYRsRJIk80G/gS8cbZBSZIkqSfsZFSSJEmSpAaZbU2b97Fm0iYBfwV+B3wrpXTXXAKTJEnS3NjJqCRJkiRJzTKrpE1K6YgexyFJkiRJkiRJkrRWWzDoACRJkiRJkiRJktRlTZuI+N9ZrDullF49i/dJkiRJkiRJkrS2qVay2HNkdPzcibHFKwYWzcw1Pf5a6LamzROBvWcxSJIkSZIkSZLqrb2wfZ2BRTJ7jd6GkdHx/YArK5POAibK9Nprevx10lXSJqU0klLacYbDffodvCRJkiRJkiTVQGMTBsNQ2N70bShxngJs0zZrW+CUum9H0+Ovm66aR5MkSZIkabZGRscXAYvmsIplE2OLl/UqHklS7TS6SaVSIH1MZdJZwNKR0fGDJsYWnzqgsLpSKWxv1yps399t6K+S4Pt4GY222QEk4OiR0fEz6vh/0fT466jb5tEkSZIkSZqtA4HL5jAcOP8hS5LmgzUkBqeLwnbIhe21rTU0DNsA7Alsx5rxtwSwfVmujpoef+3MuqZNROwLHALsCmxKhy8lpVTnfwZJkiRJ0vw4Djizw/SFwJLyeg9g+STvt5aNJE2hFEjvSa7VuAy4qAlPtFtDYuBahe2TqRa2XzgfAc3CMGxDt7WR51JruZ+aHn/tzCppExH/CnwV+H/Al4E3AF8k/xM8G/gNcHpvQpQkSZIkNVlp2myNxMvI6PiGldErJsYW3zZ/UUlS1qSExyTNTe4NHApsVZl27cjo+IeBb7ctW5vmJocg4QHNTxgMQ2H7MGxDt/+Ttfjf7aDp8dfObGvaHAZcCjwOuAc5afO/KaULImIE+AHwh55EKEmSJEmS1Fmj+8EoGrENU/RNtQB4BLA5cAPwE2Blh+VqkyyoKjU9Ps7qBe917ovkQODwLpbbCvhIh+lHAkf0MqA5aHrCA5qfMBiGwvZh2IaLgKXkGmadmhhLZf5F8xnUDDQ9/tqZbZ82DwK+nFJaAdxVpq0HkFKaAD4FvGPO0UmSJEmSJHXQ9H4woHHbMFnfVD8Ejgf+s/z94STL1a5vqkrTXNu2zapzXyTHAbuV4VHAteQC0U5Smf+oynuOm4cYu9X0hAc0P2HQKmyf6jd0FfUubG/8NpRE/UFltH07WuMH1zGhD82Pv45mW9PmduBOgJTSTRFxB6sfQK8FdpxjbJIkSZIkSWtoej8Y0MhtaO+bam/gw+V19cnqVgHdoazeNNfAC63bagstID90DJM3zfWpkdHxP7Gq5tDAawtVm5scGR3fi9WbRGsXZf5GE2OLL+x7cDPX9IQHNLyGwcTY4hUjo+MHkY9Fic7/y7UubB+GbQCYGFt86sjo+P7AMayeSF5Kjr9O54M1ND3+upltTZtfkWvbtFwOvDQi1o2IhcABwJ/mGJskSZIkSdJquugHA3I/GOvMX1Qz08RtmBhbvGxibPGPJ8YW/xi4Aji4zJos/oPIfVX9uAx1KHiv1hb6ITmh0amgHVYlPKo1h+pWW6jpNVWsIVEDpTB9f+DqtllLgboljzsahm2Af27HzpVJ+wI7Gv/aZ7ZJm9OAZ0fEBmX8P4C9gJuA68ltTY7NNThJkiRJkqQ2rX4wpipsb/WDUVdN34amxl9tWuydXb7nndSzaTFoeE2VYUh4wHAkDIahsH0YtqGo9gl2Ud1//x00Pf5amFXSJqX0kZTSDimlO8r4N8hJmxPIJ7B9Ukon9SpISZIkSZLUF9VygT3rVLNjCk2vXQDN34amxw9wQ4+Xmxcjo+OLRkbHdx0ZHd8V+Bvd9Wnzt9Z7ShNxtTEMCQ8YmoTBMBS2D8M2SLOuabOGlNJFKaV/Sym9PaX07enfIUmSJEmSBqX0qXJlZdJZwERNO1+vanTtgqLp29DU+KvNox3f5XuOp17Now1bE2/DkvAAEwaSemTd2bwpIr4KfAn4Zqu2jSRJkiRJa5n2WirnNqWQriRmTukwa1vglJHR8To/4d7ojr+Lxm1DqaHRqqXRquGxJZPHfx2lhkeZtqwG/docB5xZGd8b+HB53anz8kOB6oPJg44f1twGyNtxKDlB03ItedvaH6yuwzZ0YsJDkopZJW2APchVF2+NiDOBrwDnpJT+0bPIJEmStNZrKyCajToUEEkaQiXpcUxl0lnA0pHR8YNqnOwAoDSB9vEy2qkT+QQcPTI6fkYdC04nxhavGBkdP4icdEp0LmyvdT8YDd2GA4HDu1y2WsOj5UjgiB7HNCPlmqB6XfDjkdHxP5D/H7arTF9K3v+1+1/usA2Qt+Noch9Ci8p8Ex+S1FCzTdpsRz4RvAD4V+DFwE0RcRo5gXN+SskTgyRJaiyTBbUxkwKiTgZeQCRp+DS8lgqs6kR+MtVO5C+cj4BmamJs8akjo+P7kxNn21Zm1bawvV0Dt2Eoa3iU7+EMGp7wKPFeOOg4JElzN6ukTUopAd8FvhsRbyGfpJ8PPBd4JfCXiPh6Sun1PYtUkiRpfpksqIdOBUQAC4El5fUewPJJ3l/LAiJJzdX0WirFMHQi3ypsPxe4pUzaF2hME3XQrG0Y5hoeJjwkSXUy25o2/5RSWgmcD5wfEW8EXgV8BHgtYNJGkiQ1lcmCGpikgIiR0fENK6NXTIwtvm3+opK0lmt8LRWa24l8J8PQD0ajt8GEhyRJvTXnpA1ARCwCnkduLu1fyuTv92LdkiRJg2CyQJI0iWGopXIRuQmubZm8E/mlZTlJkiTNowWzfWNEbBkRb4yI7wBXAUcD6wBvB3ZIKe3ZmxAlSZIkSaqNxtdSKTUjDiqjqW12a/zgptX4kCRJGgazqmkTEecDjycnaS4H3gV8JaU00bPIJEmSJEmqn6GopVL6UtkfOIa8LS1LyQmbUwcTmSSpn0ZGxxfRuTbowsrrXUZGxydtBrq0SiCpT2Zb02ZLcue6O6WUdk0pfdCEjSRJkiRphqr3pHuOjI6vM7BIujRMtVRKYmbnyqR9gR1N2EjSUDsQuKzDsKSyzJJJlrmsvF9SH80qaZNSemhK6QMppd/0OiBJkiRJUlcal/CoGhkd3w+4sjLpLGCiTK+1ktTYH7i6bdZSYP+GJT1WVl5f1IRkkyRpTo4DdpvDcNz8hyytXWbVPJokSZKk6U3R/ES3bH5CHZXExjGVSWcBS0dGxw9qQsKgxH9Kh1nbAqeMjI7XPvFRmhc7F7ilTNoXONekhySpzsq1pdeXUo3Ntnk0SZIkSdObrPmJbgebn9AaKgmPbdpmtRIeta6pUmoEfbyMtvcJ0xo/uiE1h6ylIkmSpJ6ypo0kSZLUP8cBZ3aYvpBV7YbvAUza0Ws/glJzdZHwSOSExxk1TiDsCWw3xfwAti/LXTgfAUmSJEl1YdJGkiRJ6pPJmp8YGR3fsDJ6xcTY4tvmLyo13DAkPLptMnAuTQtKktQXUzR/u7DyepeR0fFJH8qx+VtJU+kqaRMRHwM+n1L6SRnfAbg+pfT3fgYnSZIkSVrNMCQ8ui2oskBLklRHBwKHT7PMkinmHQkc0bNoJA2dbmvaHAz8CPhJGf8D8FLgi32ISZIkSZLU2TAkPC4ClpL74Glv4g1yE29Ly3KSJNXNZM3fdqvO52hJNdBt0uZa4D6V8U4X1pIkSZLUFAsqr/ccGR0/t8Z9wFQ1PuExMbZ4xcjo+EHAKeR4q9uRyt+DG/J9SJLWMpM1fytJvbJg+kUAGAfeGxHfjYhWJvltEXHmFMMZfYoZgIi4Z0ScHBG3RMRNEfGZiNhomuX/OyJ+FRF/j4g/RcQxEbFp23Kpw/DCfm6LJEmS1jrtCYN1BhbJ7DV2G0ZGx/cDrqxMOguYKNNrrSQyDiqjqW12YxIeE2OLTwX2B65um7UU2L/MlyRJktY63SZtDgI+AqwHPJh8M7A98NBphn46ucTyZOAZwOOB46dYfpsyvB14CPAK4GnAZzos+0pyG9Ct4fQexSxJkqTeMGEwQE3ehhLjKeR7g6ptgVOasA3DkvAoce5cmbQvsGNT4pckSZL6oaukTUrptpTSO1NKu6eU7kuuvn5wSmnHKYb7TLfe2YqInckJl9eklC5JKX0PeAvwwohov/lqbcPPU0r/mlL6v5TS71JKFwDvAp4ZEe3NxN2UUrqmMiyfJp4NImKT1gBsPPetlCRJUicmDAarydtQknsfL6PtTYu1xo9uQhJwiBIeKyuvL6p7DSFJkiSp37qtadNub+DcXgYyQ7uTEys/qkw7j3zB/5gZrGdT4JaU0l1t0z8ZETdExKUR8aqImK4Pn8OAmyvD0hnEIEmSNN+aXkvFhMGADME27Alsx+R9dAa5RYE95y2iuTHhIUmSJA2Z9homXUkpfafXgczQ1sB11Qkppbsi4sYyb1oRsTnwHtZsUu29wAXA7cBTgE8BGwHHTLG6o4CPVcY3xsSNtNYaGR1vNa04W8tKx4Zai/k7Ur+UpEb1uuYsYOnI6PhBdX9Cv4uEQSInDM6oaeF1K2EwmWrC4ML5CGgWmr4N3R5X53L8lSRJkqRZm1XSBiAiHkZukmxXco2V9lo7qTSlNpN1jgHvmGaxnaeZ383nbAKMA78AjqjOSym9vzL6k4jYEDiUKZI2KaU7gDsq659riJKa7UDg8Dm8/0jajk2auSFIevg7Us9Vaqm0a9VSqXtfGCYMBq/p29Dtcd2ktyRJkqSBmFXSJiL2As4G/gr8CHgEuXbKQnLTZf8PuGwWq/4ocNI0y/weuAbYsi2mdYF7lnmTioiNybHfCjw3pfSPaT7vEuA9EbFBSc5I0nSOA87sMH0hsKS83gOYrL8sC4p6o+lJD39H6qkhqKUCJgzqoOnbcBG5Rvy2dG4iLZX5F81nUJIkSZLUMtuaNu8jJ0/+BVif3FTZf6aULoiIx5Cb2ZiuxswaUkrXA9dPt1xEXAxsFhG7pZRayaEnkmv7XDLF+zYBziHXinlWSmmygq6qhwN/NWEjqVuldsYahVUjo+MbVkavmBhbfNv8RbVWanTSw9+R+qDptVTAhEEdNHobJsYWrxgZHT+IXOMssfo2pPL34BonLiVJkiQNudkmbXYFDk8p3RIR9yjT1gFIKV0SEccB7ycnb3oupXRlRJwNnBARrwfWAz4BfDmldDVARGwLnA+8LKV0aUnYfAu4O/ASYJMyDeD6lNKKiHgmsBXwA3Ih3pOBdwIf6cd2SJL6x6SHtIam11IBEwYDNyTbcOrI6Pj+5OaPt63MWkqOvc5NBEqSJEkacrNN2txFbl4M4CbgH6zeXNnvgQfNPqyuvJicqDkfWAl8HXhrZf56wE7kJA3kRNNjyuvftq1rR2CCvB1vAv6LfAP6W+AQ4ISeRy9JkjS/ml5LxYRBTQzRNpwL3FIm7QucW+ffjiRJkrIp+rBdWHm9y8jo+KQtawy4D1tpSrNN2vwWuD9ASilFxC+B5wInl/mLmaZvmblKKd0IHDDF/AkqN/IppQvp/ERm9T1nk/u7kSRJczTFhXS3vJDurUbXUmkxYVAPw7AN5Ae/Wi5qWOySJElrs276sF0yxbxB92ErTWm2SZtvAq+KiMNSSncBHwNOjIjflPn3BQ7rRYCSJKmxurmQnooX0j00DLVUWkwY1MYwbIMkSZKaZ7I+bLvlw4Gqtdkmbd4PfBxYAZBS+mxErAD+tUz7j5TSST2JUJIkNdVkF9ILWfXU0x7kfuQ68UK6x4ahlkqFCQNJkiRpLTRZH7bSsJhV0ial9A/gL23TvgB8oRdBSZKk5pvsQnpkdHzDyugVE2OLb5u/qDQktVQkSZIkSRpKs61pI0mSpOaylso8sZNUSZIkSdJMzDppExFPBV4N3Ae4B2t2aJtSSvedQ2ySJElS09lJqiRJkiSpa7NK2kTEocAYcC1wKfCzXgYlSZIkDQk7SZUkSZIkdW22NW0OAi4Anl76t5EkSZLUxk5SJUmSJEkzMdukzT2AU0zYSJIkSZKmY/9OkiRJUndmm7S5FNipl4FIkiRJkoaW/TtJkiQVPtCiqcw2afNG4KyI+FFK6Yu9DEiSJEmSNHTs30mSJGkVH2jRpLpK2kTETyd57+cj4lhgKbCibX5KKe0yx/gkSZIkSQ1n/06SJEmrafQDLdYU6q9ua9rcCKS2aX8BftPbcCRJkiRJkiRJGl5D8ECLNYX6qKukTUpprz7HIUmSJEmSJEmS6q/RNYXqbrZ92kiSJK2tFlRe7zkyOn7uxNji9mZiJUmSJEkaSkNQU6jWZpW0iYiVwLXAC1JK3+0w/8XA51JK68wxPkmSpNoYGR3fDzimMuksYOnI6PhBE2OLTx1QWEPNtpIlSeD5QJIkrT3mUtNmIXBeRByaUvp4rwKSJEmqo5KwOaXDrG2BU0ZGx/c3cdMXtpUsSQLPB5IkaS0xl6TNwcCjgf+KiEcCr00pTfZEiyRJUmONjI6vA7QeUom22QEk4OiR0fEzbCqt52wrWZIEng8kSdJaYi5Jm3+klN4UEZcAxwIPiojnppT+1KPYJEnScGpinzB7AttNMT+A7ctyF85HQGsL20qWJIHnA0mStPZYMP0iU0spfQ7YA9gMuCwi9pnrOiVJ0nAqTYxdWZl0FjBRptdZpzb057KcJEmSJEnSGuactAFIKV0O7Ab8EDgbeHUv1itJkoZHpU+YbdpmtfqEqXPiptsne30CWJIkSZIkzdpcmkdbTUrppohYTO7Y7929Wq8kSWq+IegT5iJgKTnB1B4/5PiXluUkSUNmZHR8EZ1rUy6svN5lZHR8sn5el5XmvSRJkqQpzTZpsyNwffvElFICDo+IrwH3mktgkiRpqDS6T5iJscUrRkbHDyLXFEqsnrhJ5e/BNU04SZLm7kDg8GmWWTLFvCPJDzhKkiRJU5pV0ial9Mdp5v98duFIkqQh1fg+YSbGFp86Mjq+P3AMucZNy1JywubUwUQmSZoHxwFnzuH91rKRJElSV2bdPFpE3AN4EXAf4B6s2VRISinZt400z6ZouqFbA2+6YRi2QdIahqJPmJK4ORe4pUzaFzjXGjaSNNzKtWWtz1GSJEkaDrNK2kTEU8nNg2xILrT4a4fFUodpkvqvm6YbplKHphuGYRskrW6Y+oRZWXl9kQkbSZIkSZLUK7OtafNR4Bpgv5TSz3oYj6S5m6zphoWsamd7D2DSTlL7EdQMDcM2SKqwTxhJkiRJkqTpzTZpcz/gUBM2Uv1M1nTDyOj4hpXRKybGFt82f1HNzDBsg6Q12SeMJEmSJEnS1GabtPkNsHEvA5EkScPPPmEkSZKktdcUfdgurLzeZWR0fNKWNezDVtKwm23S5t3AJyPiiymliR7GI0mShp99wkiSJElrp276sF0yxTz7sJU09GabtNkHuB64MiLOBa4C2gtcUkrpoLkEJ0mSJEmSJGloTNaHbbesZSNp6M02afPmyutnTLJMAkzaSJIkSZIkSZq0D1tJ0ioLZvOmlNKCLoZ1eh2sJEla7dy958jouOdbSZIkSZKkITGrpI0kSZp/I6Pj+wFXViadBUyU6ZIkSZIkSWq42TaPJg2tkdHxRcCiOaxiWanuK0k9UxIzp3SYtS1wysjo+P4TY4tPneewJEmSJEmS1EOzTtpExL7AIcCuwKZAtC9jE2lqqAOBw+fw/iOBI3oTiiRBaQLt42W0/Xwb5H7kjh4ZHT9jYmzxinkNTpIkSZIkST0zq6RNRPwr8FXg/wFfBt4AfJFccPRs4DfA6b0JUZp3xwFndpi+EFhSXu8BLJ/k/daykdRrewLbTTE/gO3LchfOR0CSpPkzRU3whZXXu4yMjk96fWpNcEmSJKkZZlvT5jDgUuBxwD3ISZv/TSldEBEjwA+AP/QkQmmelRvaNW5qR0bHN6yMXjExtvi2+YtKUg9V+3Pbc2R0/NwG1E7ptsnGuTTtKEmqr25qgi+ZYp41wSVJkqSGWDD9Ih09CPhySmkFcFeZth5ASmkC+BTwjjlHJ0mqm/aER6OawSz9wlxZmXQWMFGm11m3T0f7FLUkDafjgN3mMBw3/yFLkiRJmo3Z1rS5HbgTIKV0U0TcwepP914L7DjH2CRJNVISG8dUJp0FLB0ZHT9oYmzxqQMKq2sl/lM6zNoWOGVkdHz/Gm/HRcBScqxr9CFH7tNmaVlOkjRkJqsJLkmSJGn4zLamza/ItW1aLgdeGhHrRsRC4ADgT3OMTZKGTWNrqVQSHtu0zWolPGpdU6Xs64+X0fakR2v86Lp+J6X5toPKaGqb3Ro/uAHNvEmSJEmSJGkKs03anAY8OyI2KOP/AewF3ARcT+4IeWyuwUnSsGhws1yNT3gUewLb0bmWCmX69mW5Wiq1gPYHrm6btRSocy0hSZIkSZIkdWlWzaOllD4CfKQy/o2I2AvYD1gBjKeUvt2LACWp6RreLBesSnhMpprwuHA+ApqFRdMvMqPlBmJibPGpI6Pj5wK3lEn7Audaw0aTGRkdX0Tn3/XCyutdRkbHl0+yimWlWSZJkiRJkjQPZtunzRpSShdhW/qStJouaqkkci2VM2pc8D4MCY9uC52bUDi9svL6ohr/blQPBwKHT7PMkinmHQkc0bNoJEmSJEnSlHqStImIdYH7AxsBV6aU/taL9U7zmfcE/ht4JrkA6+vAQVN9dkRcCDyhbfJxKaXXV5bZATgW2Bv4G/BZ4LCU0l093QBJs9HeJ0wTahgMQy2VYUh4XERuRmxbOjeRlsp8Hz7oIWt51MJxwJlzeL/7X5KkHvHaSJIkdWNGSZuIeDrwIuAu4PMppQsi4jnAJ1h14XFnRHw0pfTunka6ppPLZz4ZWA84ETgeOGCa950AvLcyfnvrRUSsA4wD1wCPLev/HPAP4J29ClzSzJUmxo6pTDoLWDoyOn5QzZsWG4ZaKo1PeEyMLV4xMjp+ELmZusTq25HK34MbkARsGmt5DFgp2LFwR5KkevDaSJIkTavrpE1EPA34BjmB8XfgJRHxKuAzwC+Ar5X1PRU4LCL+mFI6ofchQ0TsDDwNeFRK6Udl2luAb0bE21NK7Z00V92eUrpmknlPAR4EPCmldC1weUS8B/hgRByRUrqzh5shqUsN7xOm8bVUhiXhUfqD2Z+c/Nu2MmspOf66/oaazFoekiRJq3htJEmSpjWTmjb/DvwceHxK6aaI+B/yBce5wDNSSgn+2VTaD4DXk2u19MPuwE2thE1xHrmZtMcAp03x3hdHxEvItWn+D3h/SqlV22Z34GclYdNyDrm5tAcDP+m0wojYANigMmnjGWyLpCkMQZ8wja+lAsOT8CjbcS5wS5m0L9CEZvYayVoekiRJq3htJEmSurFg+kX+6cHASSmlm8r4MeR2V7/QStgAlL5fTgYe2KsgO9gauK46oXzujWXeZL4IvITcX81RwEuBL7St99q291xbmTeZw4CbK8PSqcOXNAOtPmE6JTxg9T5haqckAw4qo6ltdmNqqUBOeAA7VybtC+zYlIRNxcrK64uasO8lSZIkSZK0dphJ0mYLVk9otJIm7UmO1ryFHaZPKSLGIiJNM8w6GZRSOj6ldE5K6WcppZOBlwHPjYj7znadxVHAppVhqk7HJc1M4/uEKUmN/YH2phuXAnVu2q0TEx6SJEmSJElSn8wkaQOrPyXe/sR4L3yU/BT3VMPvyU2bbVl9Y2mW7Z5lXrcuKX/vV/5eA2zVtsxWlXkdpZTuSCnd0hqAW2cQg6SpNb5PGBiqWiqSJEmSJEmS+mQmfdoAjETEruX1puXv/SPiprbldpxNMCml64Hrp1suIi4GNouI3VJKl5XJTyQnoS6Z/J1reHj52yrsvRh4V0RsmVJq1SR6Mrnvg1/MYL2Semco+oQprKUiSZIkSZIkaVIzrWnzfuCHZTivTPtUZVpreF+vAuwkpXQlcDZwQkQ8OiL2AD4BfDmldDVARGwbEb+MiEeX8ftGxHsiYreIGImIZwGfA76bUvppWfW3yMmZz0fELhHxVOADwCdTSnf0c5skdTZMfcJIkiRJkiRJ0lRmUtPmlX2LYnZeTE7UnE9+ev3rwFsr89cDdgLuXsbvBJ4EHAxsCFxV3vOB1htSSisi4hnAseRaN7cBnwXe28ftkOZLNUm758jo+LlNSXRMjC0+dWR0fH/gGHKNm5al5ISNTYxJkiRJkiRJaryukzYppc/2M5CZSindCBwwxfwJKk0ppZSuAp7QxXr/CDy9ByFKtTEyOr4fOeHRchawdGR0/KCmJDxK4uZccnOFkPuEaUziSZIkSZIkSZKmM9Pm0SQ1TEnYnAJs0zZrW+CUMr8p7BNGkiRJkiRJ0tAyaSMNsZHR8XWAj5fRaJvdGj+6LCdJkiRJkiRJGiCTNtJw2xPYjjUTNi0BbF+WkyRJkiRJkiQNkEkbabgt6vFykiRJkiRJkqQ+MWkjDbdlPV5OkiRJkiRJktQnJm2k4XYRsBRIk8xPwFVlOUmSJEmSJEnSAK076AAk9c/E2OIVI6PjBwGnkBM01b5tWomcgyfGFq+Y9+AkqeZGRscX0bn5yIWV17uMjI4vn2QVyybGFluTUZIkSZIkdc2aNtKQmxhbfCqwP3B126ylwP5lviRpTQcCl3UYllSWWTLJMpeV90uSJEmSJHXNmjbSWmBibPGpI6Pj5wK3lEn7Audaw0aSpnQccOYc3m8tG0mSJEmSNCMmbaS1x8rK64tM2EjS1ErTZiZeJEmSJEnSvLF5NEmSJEmSJEmSpBowaSNJkiRJkiRJklQDJm0kSZIkSZIkSZJqwKSNJEmSJEmSJElSDaw76AAkSZIkqV9GRscXAYs6zFpYeb3LyOj48klWsWxibPGy3kcmSZIkSWsyaSNJkiRpmB0IHD7NMkummHckcETPopEkSZKkKZi0kVQ7PhErSZJ66DjgzDm832sKSZIkSfPGpI2kOvKJWEmS1BPlQQ4TL5IkSZIawaSNemqKGhLdsoaEwCdiJUmSJEmSJK2FTNqo17qpITEVa0jIJ2IlSZIkSZIkrZVM2qjXJqshsZBVzVntAUzaF0k/gpIkSZIkSZIkqe5M2qinJqshMTI6vmFl9IqJscW3zV9UkiRJkiRJkiTV34JBByA1SPX/Zc+R0fF1BhaJJEmSJEmSJGnomLSRujAyOr4fcGVl0lnARJkuSZIkSZIkSdKc2TyaNI2SmDmlw6xtgVNGRsf3nxhbfOo8hyVpyI2Mji8CFnWYtbDyepeR0fFJ+wgrTVZKkiRJkiSpIUzaSFMoTaB9vIxG2+wAEnD0yOj4GRNji1fMa3CSht2BwOHTLLNkinlHAkf0LBpJkiRJkiT1nUkbaWp7AttNMT+A7ctyF85HQJLWGscBZ87h/daykSRJkiRJahiTNtLUOjVNNJflJKkrpWkzEy+SJEmSJElrkQWDDkCquW4LTC1YlSRJkiRJkiTNiUkbaWoXAUvJfdd0koCrynKSJEmSJEmSJM2aSRtpChNji1cAB5XR9sRNa/zgspwkSZIkSZIkSbNmnzbSNCbGFp86Mjq+P3AMsG1l1lJywubUwUQmaSojo+OL6Nzf1MLK611GRseXT7KKZaVfGUmSJEmSJGlemLSRulASN+cCt5RJ+wLnWsNGqrUDgcOnWWbJFPOOBI7oWTSSJEkD5AMtkiRJzWDSRureysrri0zYSLV3HHDmHN5voYQkSRomPtAiSZLUACZtNF+q/SftOTI6bi0VSX1VngQ18SJJkpT5QIskSVIDmLRR342Mju9H7g+m5Sxg6cjo+EH2B9N7NnsgSZIkqZ0PtEiSJDWDSRv1VUnYnNJh1rbAKSOj4/ubuOk5mz2QJEmSJEmSpAYyaaO+GRkdXwf4eBmNttkBJODokdHxM2wqrads9kCSJEmSJEmSGsikjfppT2C7KeYHsH1Z7sL5CGhtYLMHkiRJkiRJktRMJm3UT536VZnLclIj2K+QJEmSJEmSpNkwaaN+6rbQ2cJpDRv7FZIkSZIkSZI0YyZt1E8XAUuBbVmzTxvIfdosLctJw8R+hSRJkiRJkiTNmEkb9c3E2OIVI6PjBwGnkBM01cRNKn8PnhhbvGLeg5P6yH6FJEmSJEmSJM3GgkEHMFsRcc+IODkibomImyLiMxGx0RTLj0REmmR4XmW5TvNfOD9bNXwmxhafCuwPXN02aymwf5kvSZIkSZIkSdJar7FJG+Bk4MHAk4FnAI8Hjp9i+avIHYNXh8OBvwFntS37yrblTu9h3GudkpjZuTJpX2BHEzaSJEmSJEmSJK3SyObRImJn4GnAo1JKPyrT3gJ8MyLenlJqr9VBSmkFcE3bep4LfDWl9Le2xW9KKV2Demll5fVFNokmSZIkSZIkSdLqmlrTZndyYuVHlWnnkRMDj+lmBRGxG/Bw4DMdZn8yIm6IiEsj4lURER2Wqa5rg4jYpDUAG3e1FZIkSZIkSZIkSUUja9oAWwPXVSeklO6KiBvLvG68GrgypfT9tunvBS4AbgeeAnwK2Ag4Zop1HUZuak2SJEmSJEmSJGlWalXTJiLGIiJNMzywB59zN+AAOtSySSm9P6W0JKX0k5TSB4EPAYdOs8qjgE0rw3ZzjVGSJEmSJEmSJK1d6lbT5qPASdMs83ty3zRbVidGxLrAPWnrt2YS+wN3Bz7XxbKXAO+JiA1SSnd0WqBM/+e8aVpTkyRJkiRJkiRJWkOtkjYppeuB66dbLiIuBjaLiN1SSpeVyU8k1xy6pIuPejVwZvm86Twc+OtkCRtJkiRJkiRJkqReqFXSplsppSsj4mzghIh4PbAe8AngyymlqwEiYlvgfOBlKaVLW++NiPsBjwee3r7eiHgmsBXwA2A58GTgncBH+rtFkiRJkiRJkiRpbdfIpE3xYnKi5nxgJfB14K2V+esBO5GbQat6FbAU+FaHdf4DeBPwX0AAvwUOAU7oZeCSJEmSJEmSJEntGpu0SSndCBwwxfwJcuKlffo7ybVnOr3nbODsHoUoSZIkSZIkSZLUtQWDDkCSJEmSJEmSJEkmbSRJkiRJkiRJkmrBpI0kSZIkSZIkSVINmLSRJEmSJEmSJEmqAZM2kiRJkiRJkiRJNbDuoAPQcBkZHV8ELOowa2Hl9S4jo+PLJ1nFsomxxct6H5kkSZIkSZIkSfVm0ka9diBw+DTLLJli3pHAET2LRpIkSZIkSZKkhjBpo147DjhzDu+3lo0kSZIkSZIkaa1k0kY9VZo2M/EiSZIkSZIkSdIMLRh0AJIkSZIkSZIkSTJpI0mSJEmSJEmSVAsmbSRJkiRJkiRJkmrApI0kSZIkSZIkSVINmLSRJEmSJEmSJEmqAZM2kiRJkiRJkiRJNWDSRpIkSZIkSZIkqQZM2kiSJEmSJEmSJNWASRtJkiRJkiRJkqQaMGkjSZIkSZIkSZJUA+sOOgCpbkZGxxcBizrMWlh5vcvI6PjySVaxbGJs8bLeRyZJkiRJkiRJGmYmbaQ1HQgcPs0yS6aYdyRwRM+ikSRJkiRJkiStFUzaSGs6DjhzDu+3lo0kSZIkSZIkacZM2khtStNmJl4kSZIkSZIkSfNqwaADkCRJkiRJkiRJkkkbSZIkSZIkSZKkWjBpI0mSJEmSJEmSVAMmbSRJkiRJkiRJkmrApI0kSZIkSZIkSVINmLSRJEmSJEmSJEmqAZM2kiRJkiRJkiRJNWDSRpIkSZIkSZIkqQZM2kiSJEmSJEmSJNWASRtJkiRJkiRJkqQaMGkjSZIkSZIkSZJUAyZtJEmSJEmSJEmSasCkjSRJkiRJkiRJUg2YtJEkSZIkSZIkSaoBkzaSJEmSJEmSJEk1YNJGkiRJkiRJkiSpBkzaSJIkSZIkSZIk1YBJG0mSJEmSJEmSpBowaSNJkiRJkiRJklQDJm0kSZIkSZIkSZJqwKSNJEmSJEmSJElSDTQ2aRMR74qI70fE7RFxU5fviYh4X0Qsi4i/R8R5EXH/tmXuGREnR8QtEXFTRHwmIjbqy0ZIkiRJkiRJkiQVjU3aAOsDXwOOncF7/h14K/B64DHAbcA5EbGwsszJwIOBJwPPAB4PHN+LgCVJkiRJkiRJkiaz7qADmK2U0uEAEfGKbpaPiAAOBj6QUjqjTHsZcC3wHODLEbEz8DTgUSmlH5Vl3gJ8MyLenlK6epJ1bwBsUJm08Sw2SZIkSZIkSZIkrcWaXNNmpnYEtgbOa01IKd0MXALsXibtDtzUStgU5wEryTVzJnMYcHNlWNq7sCVJkiRJkiRJ0tpgbUrabF3+Xts2/drKvK2B66ozU0p3ATdWlunkKGDTyrDdXIOVJEmSJEmSJElrl1olbSJiLCLSNMMDBx1nu5TSHSmlW1oDcOugY5IkSZIkSZIkSc1Stz5tPgqcNM0yv5/luq8pf7cCllWmbwVcXllmy+qbImJd4J6V90uSJEmSJEmSJPVcrZI2KaXrgev7tPo/kBMv+1CSNBGxCbmvmmPLMhcDm0XEbimly8q0J5JrJF3Sp7gkSZIkSZIkSZLq1TzaTETEDhHxcGAHYJ2IeHgZNqos88uIeC5ASikBRwPvjohnRcRDgc8BVwOnl2WuBM4GToiIR0fEHsAngC+nlK6ev62TJEmSJEmSJElrm1rVtJmh9wEvr4z/pPzdG7iwvN4J2LSyzIeADYHjgc2A7wFPSyktryzzYnKi5nxgJfB14K29DV2SJEmSJEmSJGl1jU3apJReAbximmWibTwB7y3DZO+5EThg7hFKkiRJkiRJkiR1r7HNo0mSJEmSJEmSJA0TkzaSJEmSJEmSJEk1YNJGkiRJkiRJkiSpBkzaSJIkSZIkSZIk1YBJG0mSJEmSJEmSpBowaSNJkiRJkiRJklQDJm0kSZIkSZIkSZJqwKSNJEmSJEmSJElSDZi0kSRJkiRJkiRJqgGTNpIkSZIkSZIkSTWw7qADkCTVz8jo+CJgUYdZCyuvdxkZHV8+ySqWTYwtXtb7yCRJkiRJkqThZdJGktTJgcDh0yyzZIp5RwJH9CwaSZIkSZIkaS1g0kaS1MlxwJlzeL+1bCRJkiRJkqQZMmkjSVpDadrMxIskSZIkSZI0jxYMOgBJkiRJkiRJkiSZtJEkSZIkSZIkSaoFkzaSJEmSJEmSJEk1YNJGkiRJkiRJkiSpBkzaSJIkSZIkSZIk1YBJG0mSJEmSJEmSpBowaSNJkiRJkiRJklQDJm0kSZIkSZIkSZJqwKSNJEmSJEmSJElSDZi0kSRJkiRJkiRJqgGTNpIkSZIkSZIkSTVg0kaSJEmSJEmSJKkGTNpIkiRJkiRJkiTVgEkbSZIkSZIkSZKkGjBpI0mSJEmSJEmSVAMmbSRJkiRJkiRJkmrApI0kSZIkSZIkSVINmLSRJEmSJEmSJEmqAZM2kiRJkiRJkiRJNWDSRpIkSZIkSZIkqQZM2kiSJEmSJEmSJNWASRtJkiRJkiRJkqQaMGkjSZIkSZIkSZJUAyZtJEmSJEmSJEmSasCkjSRJkiRJkiRJUg2YtJEkSZIkSZIkSaqBSCkNOoahExGbADcDm6aUbhl0PJIkSdJsjYyOLwIWdZi1EFhSXu8BLJ9kFcsmxhYv60dskiRJktQU3eYN1p2/kCRJkiQ10IHA4dMss2SKeUcCR/QsGkmSJEkaYiZtJEmSJE3lOODMObzfWjaSJEmS1KXGNo8WEe8CFgMPB+5MKW02zfLrAR8Ang7ch1wN6TxgNKV0dWW5CeDebW8/LKU0NoPYbB5NkiRJkiRJkiQB3ecNFsxfSD23PvA14Ngul787sCvw/vJ3P2AnOj81+F5yu92t4b/nGqwkSZIkSZIkSdJUGts8WkrpcICIeEWXy98MPLk6LSLeDFwaETuklP5UmXVrSumaXsUqSZIkSZIkSZI0nSbXtOmFTYEE3NQ2fTQi/hIRP4mIQyNiyuRWRGwQEZu0BmDjPsUrSZIkSZIkSZKGVGNr2sxVRCwEPgh8qa39uGOAHwM3Ao8FjiI3kXbIFKs7DDi8T6FKkiRJkiRJkqS1QKSUBh3DP0XEGPCOaRbbOaX0y8p7XgEcnVLabAafsx7wdWA7YK+pOv2JiFcBxwEbpZTumGSZDYANKpM2BpYyTYdCkiRJkiRJkiRp+JVWum5mmrxB3WrafBQ4aZplfj+XDygJm68C9wae2EVS5RLyfhoBftVpgZLM+WdCJyLmEqIkSZIkSZIkSVoL1Sppk1K6Hri+X+uvJGzuD+ydUvpLF297OLASuK5fcUmSJEmSJEmSJNUqaTMTEbEDcE9gB2CdiHh4mfXblNLfyjK/BA5LKZ1WEjanALsCzyjv2bq858aU0p0RsTvwGODbwK3A7sB/AV9IKf11njZNkiRJkiRJkiSthRqbtAHeB7y8Mv6T8ndv4MLyeidg0/J6W+BZ5fXlbetqvecO4IXAEeQ+av5ATtp8rFdBS5IkSZIkSZIkdRIppUHHMHS67VBIkiRJkiRJkiQNv27zBgvmLyRJkiRJkiRJkiRNxqSNJEmSJEmSJElSDZi0kSRJkiRJkiRJqgGTNpIkSZIkSZIkSTVg0kaSJEmSJEmSJKkGTNpIkiRJkiRJkiTVgEkbSZIkSZIkSZKkGlh30AEMuY0jYtAxSJIkSZIkSZKkwdq4m4VM2vRHa+cvHWgUkiRJkiRJkiSpTjYGbplsZqSU5jGWtUPk6jXbALcOOpaa2ZicyNqO5u6bpm9D0+OH5m9D0+MHt6EOmh4/NH8bmh4/uA110PT4ofnb0PT4wW2og6bHD83fhqbHD83fhqbHD25DHTQ9fmj+NjQ9fnAb6qDp8ffbxsDVaYrEjDVt+qDs8D8POo66qTQVd2tKadJMYp01fRuaHj80fxuaHj+4DXXQ9Pih+dvQ9PjBbaiDpscPzd+GpscPbkMdND1+aP42ND1+aP42ND1+cBvqoOnxQ/O3oenxg9tQB02Pfx5Mu08WzEcUkiRJkiRJkiRJmppJG0mSJEmSJEmSpBowaaP5dAdwZPnbVE3fhqbHD83fhqbHD25DHTQ9fmj+NjQ9fnAb6qDp8UPzt6Hp8YPbUAdNjx+avw1Njx+avw1Njx/chjpoevzQ/G1oevzgNtRB0+MfuJiivxtJkiRJkiRJkiTNE2vaSJIkSZIkSZIk1YBJG0mSJEmSJEmSpBowaSNJkiRJkiRJklQDJm0kSZIkSZIkSZJqwKSNJBUREYOOQZIkSb0TETtFxA6DjkOSJEnqlkkbaZ5FxILy9z6DjqUfmpT4qHwXDwZIKaXBRtQsEbHZoGOQOmn9b0tru7qfk+sen4bGOHBhRLwgIjYddDDDICI2i4j1Bh2H1K4f14BeVzZbRKxb/m446Fg0d5Xv8/HlvL5BHz9r+36tW+qGJx/VXvsNfWu8iTf6EbEgpbQyIrYFPhsR+0XEOoOOqxci4oERsU1TEh+V72IL4DsR8W9Nu/kc5A1ERDwP+EtEHNi6cJIGpXJe2D4i1kkprRx0TFIdtM7JEfGYiHjYoOOpPCyxQURs35RrBjVXuc5+M3Al8EXgCxHxuIi422Aja7xvA09pwv1YE2LU7FWuAbeOiLv16RrwteVed60tP2uVWTQp8dH6baSU7oqIjYAPR8TOAw5Lc5RSuqu8PAnYE7hHPz4nIt4M/Ec/1t0Ek5XDan6ttScdNUelwOHeEbExENXpTVK5iDwCuBfwm5TSisFFNDeVpxweCxwP/HdELCzTap1cq3wXrweuAZaklP4xwJC60nazsG5E3KPcpKw/z6EsA/4POBq4OCKePM+fP2uVQsN1IuLug45Hc1OSNKnUXvwMcFY5V8z78aecp/aIiL3L/+UW8/n5UlXlHP0M4FjgXZVCl4Gcoyvn3k8AY/P52b2yNhfaNVFKaUVK6WzgpcCrge2Ac4D3RMSD5uvhqcq1Ry2vi2ciIt4HPBC4ZbL7sTr9nzTxnrElIhb18ynypqtcA94bOIb8UOQmPf6MZ5HPoZ8BXhgRW/dy/U2RUlpR7ptOjIgXRsQ9Bx3TVMrDmI+PiN3KpE8B+wI+2DUEyoNIK4BvppSu6dPH7A/sNAzn7Zmonr9LrdpHRsRO/TqXRsQ9I2KHiNiq18fvYVCbiympXaVgYc+IOAn4LrAU+FpEvCYa1jRT203hD4GLUko/G1Q8vVB5yuFTwB3Ax1NKy8u8VP1bJ201Q34G/DGldGmZV+uTcqvAKyLeQP6f+BPwLeDTEfGUeYzje8CBwCuBO4FzIuILEXH/+YphtiqFhh8CXjzIWPphbXsqppL4PhbYBPh0SunWMm9ejj8R8fCIOBr4f8B3gPOBy4BPRcQrIuJe8xFHv9Sp8G2mmhz7XEREVM7RxwATwFGV/5eIiPUqD8bMy3Gi7XOeGREPms/Pn4vWtYM1+ZoppXQjcDL52uW3wCjwdeBN/S6ELb/vFBHr1vG6eCbKwwiHAf8JXF6mLYyI3SLiWRHx8ojYsHK9Ou/H4Mo95Asi4tXz/fm9UvbdW4C9p1qmCcfPfqmc0z4F3A84JaV0S48/40yg9XDa58kPKT5pLS1cvA+5IPu9wBGRm6ea7wcHu7UT+V7vCxFxFPme74MppV9Bc64PKwn/B0bE2yPi0xFxUEQ8oSnb0CuVfXF3YHPgb8BfyrR+tPzxDeBh5Ic91iat65QDgQvI97U/joizI+JRvfiAyoNljwZOJ9+n/BA4NiKe16fvs5HWqn9yNUfkpqtWRK7G+gXgUeSD5n8AzyE/LbfR4CKcudZFZUR8HngDcP8yvmC+nvLrpcpJ8w3AtsBHUkrfLdO2jogPRMS3IuLQKLVv6qJVkBURZwHvAhaVzH7U+Wa6cnJ7Hfl/4R/AocBvgJcAj5mPfd26OUwpXZtS+jLwGuBjwAHADyLivVHzNuPL01c7AcdExH5lWqNveivfS4rc9NBDIuI+Zbxxx5huVI5DzwQeS6759fUybZOIeGtEfC4i3hh9qvUSEZsDnwaeD3wOOAR4P3AhsBj4H+BDEbFLWb4xv7OIuFtEbFApfKvt76i1XyPiAeVhj+dExBZNiL1PWvtjFNgAODqldHmZ9gDyE8OXR8QnIuJe83Xuq3zOJ8vf51enRzEfsUynUvB7/4h4G/CliLiwHE8WDTg8zUDl///fycfk64BzgRvI1y+nl2NGT65dKr+dLUvS4Ifkc8LxEfHCXnzGAH0S+BXw1ZTSrZFrtn6WvI2nAycC10TEO2D+kpzV40alIP9I4KFlfuMKgMq+W598jb+acv94t5TSyjrfu/RT5RrwGcATgI8Ap5Zpdy8JxE+VAsA5lXullM4HHk9uoeGxwCnk2nqPqHHSoicqx7NFwPbApcAO5GYnTwTeHuUBjLqIXAPr58B7gL+Tr81vBNZpJdtKM+n/vOaoy7VHVdmOlRGxE/n4+gHy73CMnKj8SKyqSTT0KueTD5LLBkcoZWqlCbxeX+t/m3wNvQfU8zfSa7Gq9uLu5PvqG4F3kxO1TyG3sPLpiNhhLp9TebDsBPLx5MPk5NAzydcZJ0bEE+byGUMjpeTgULsBiPL3WHKB9OPL+CLgNvITXhuWaVsMOt4ZbNcuwLXkGkN/BV5YmbcAWDDoGGe4PQuA08gntM3LtN2BM8hVj39Orrb6FWC91vdahwHYBjgPuLrE+gFgnervr44DsC65ObdjgW3LtFeW39OjKt/LTv38PVX21abkZm5+A/yI3GzancAfyMnV2v6myTfyl5NrRNxn0PH0YHsWlL8HkJ+KubH8/30XeDmw0aBj7OO2f4FcYHSfMr4TuVB6JfnJnZXkGjj9+OyvlmPd09umb1CO+aeUzz+1dd6q61D5v34MuXbGd8vx/dC25WpzjCzHxFbcu5H7rVgB3FqOR//Ztnxtj0l92Dfrld/d+cDdy7R9gYuA28mF1reWc+Hd+/29tu974OPlfLZ9h2UH+hurHE83Lv/ffwV+TC54X0m+rtm0LvH2aJsbvw3TfJePKMeGw4CFZdo2wH7l/HEncBzwaGCDHn326eW3cyH5evmv5KeCHzPo/TLL7Xl0+f2/t/X7B75UtuvoMv9N5OZzV5bz4yaD+L7L62OBi8vrRv6+gaeV4+R9y/iu5ALLJcAVZb/vXFl+nUHHPIB99CXgB8BIGb8v+d5kZfl/Wwl8ole/A3IT5x8ClpPvf95KroHSyN/YDLb7bOCnZXv3JNc+Oq/s3++Rm59c43w+gDi3aBt/VonxVnI50vHAE1vngbLMuuUc8ZQ6fo/lHHIp8Nwy/pKyTbeU7+RtwL0HHec87o9Xk+9R7ijn7je1zZ/zcZBcnrJROf4eP9kyg94XfdzHFwFnAQ8s488s+/srwE3ke6w3MYfyhXLN8Etg38q0ncsx/Vbgd+QE5U6D3h8D/S4GHYCDw2QDuUOxHwL/1ToYlH/gn7cuCMiFYn8C9h90vDPYrt3INxE3l5Ptp4EdK/MbdbFN7gDuT+X1luTmga4Enkt+OuzoclDfbNCxdoh9R+B15ELJleSCrYdX5tfxou2Z5ELop5fxrcoF2/tZVQjxDPKF9aI+xtFKrJ5CTny8uIzfD3he+fyVwDg1Lpwo/49Ly7Fmx0HHM4ftaBVaP4JcVfzb5KfKXl35HjYfdJx93P5jyM0cUo47F5b/k0OADcv/x9+AbXr8uQ8rx/LXUgr5gPXaltmIXMC1shwv16OGF/msKtjcEvgj+QGDc8kX7CvJidjnVZcf5DGSSqK1cjz6Efnm9dXlO/kc+QnL64CX1SX2edxHQU5eXk8uZHpYOd5dCvxLWeZD5IcX+nZ8aN/X5Cd1twD+jXyzfVQ5b/0bufbrh8s55GX9iqmLmFv/DyeRC+WeUcYfXWJ+B3C3Mm3dQX/X0+3zyaaV6ev1M5a6DMBHyYUvD23/rsu1wK/LsW4l8JY5fE7rfPz8cvx5VeX39GtyE21blvEtKQnVJgysuqb4I7mW9XPItb5fxuoFoCPlf2cl8MR5iOtI4EnV77TyHVwDbD3ofTeHbVu/HCMXkZ8o/xP5uuP75Zx3cxkOH3SsA9o/65Cf1P5dZdo5wFXkJhC3Bf6b/CDTvXrweVF5/SByYnYluWnc/WnQw6Qz2V5ykmNFp/My8ALyddZ15Fp3T60eD+Y53jeX7+MlZXxB+Q0cQL5HPbpsx5+Aw4FdynLbAJcAnxz0Pu+w7/cu+/ZFlWnfJd/bvbjMu5n80OxrqeE9Rp/2z+blf/zX5AeRzq6eb5jltX77bxf4Grl8a9IH78j3es+iPEDb9IFcm/DX5TzfOp/+nJyw2Y58vd66XlpK5SGmGX7OpsAvgEeW8fUr8/Yt57mbyPf0Txj0fhnY9zHoABwcOg2VE9KPyU16QH6iYyXwwsrB41HlIPrmQcfcxTat0zb+dPKTaDeSCwTeMagLnNlsBzmpdjdyQcsN5JuiG8nZ8mdWln8bue3wBw869im2aVdyoeofy2/sk/Tgwr5PsT6O/JRDq/bZieX3U038vbN8Dw/qcyz3JT8F8T7WLKh+ALnd55XkG/rTqFHBBJWCc+BfyYnFz7Cq4L2RF7zkxOMFre+efKF/J7ngYr0yrbb/i3PY7meW7fxluci8Dnh5Zf4byTfwPb2YJt8cXQXsMc1ymwPfJD/xOTLo/TVJjK3z7hfLefXJZfxx5ILH1vHxXCpP9Q4o1vXJN6gXA48o0+5dzjXPryy3BbkQpZV4+iE1TiL3aV/tRb7ZuZ1cUPH91vmjzD+k7Le+faeVY+1h5JuvP5d4/syqm76bynf6F3KC8DfAdgPed9uSC3beRaktQL5hvYJVDw9tUo65Dx/0dz3JNjybypPP7ec2cmLvIHLh1dAm9su2vqX81h5Wxtdn9QLYF5ATmkcDu/bg804vx/3tyvjryNdve1SOtx8CXjrofTODbdqQXJhzGnBX2Z/fpBRUU7nXIddSu5PcfHI/Y3oIucZDqxZ69Xr4EeX89bQO71tAvo/cZdD7tYtt3KH8PbOcx55Yxrck13b4bPkuTmOWhWdNHshlA38nlxtcXs4jr6vMf2s5Dz6iB5+1RpKe3BTuFeX3fiKwDyWpPywDuVm42yq/vWD1Wm2HlO2/s/wvDuS4Rq6BsoRSwAvcv8MyD2PVw4U/JD8o8pVyTKvdA3zkxMSVrEowPZd8b93axmeSH+BcDpww6Hj7uB8me/Bkl3LsX0q+/zseuN8cPucCcvPzrVZkWrWaHlZZZivgSeQyl1brFiuBhwx6P/VoXz+JfG/wuDL+AvJ1++Mqyywh15h/zWy+R/L1xFblvFVNtm3Qtvy/kR/IG6pj6oz22aADcHDoNJQLgSDf8PwM2JpcOPMNVj2dtj65St61lJuryQ7mg9yODtu0qDJtYbkIuoRcWLGEUtBYt23psG1fJ18Eb0fOwp9AvlC9b+VgPFIOxD+oQbzV7+Ju5STxkMq0heTCrePIT+RfC7xz0HF32I77k5+KPoT8tPJd5CcfW8mGHcjN4VzYj33Yth+3ITeJcVQZ/2czRWV8I3LTY+PAyQPaX63CwlaysWMVXnI79yuBjw76O57Dto6Q25l/D+VJFfIN7P8B96j8PpYDzx50vD3a5tb3ejdyM4GnkRNXj6PcWJf/9f8BftnDz20d415S/gcfUsYnfeK+xLSSGhbQVbZnZ3LBxltY1QTpmeSCzMeRa660CtlPK//z836uIhemH08u3L+rnH9aF/57Vn8b5fUI+enLy0rsrx30Pp/H73R98g3+kWW4R2WZncr/y/l9+PxHUXniuPxWvkhu1udIcsLzheRmNK8i3/jdoxyj1qUGD7GQrz3/2Pq9kK8RVpKT4K1zy9PIieJnDDreDvHvXuI9nXzDfbfKvFb825JrYq2krQbKsA3kfgDuIhdwV69lWtdPLwB+wiwKe9qON0F++v8U4Lwy7e7k68qjWVVDa3vyE6ZH0bxa9puSa1V/C/jf9u2v/Lb+QH4Qqq8PwpRj3Bl0eBCOfF30wfJ6V/LT6ieV2FZSedCsjkNlfz6Q/JDcu2m71ii/pVZzYLU7FvVx37SOY/ckF56eR34wYR9WXQdvRS7Q/SWze+q+dZ25iFyr4ThyAf/zyPdkrfnrk++LrycnLgbeTFiP9/VjyQ9+vLOMt45z1d/n2eQk6qnlt/jC1rLzHGursH1TciH+OJUC98pyzyY/pLSS3AzT2wa9nyfZnqdTaeKZ3BTg1yrb+ZAybVdg40HH24ftr56vNyc3+X0A+aHLDSvznlrOA9eQy3JmfCwkX4N+h/yAxaXk2qS7lHPLl8nN6bfuJVaW/4mfkZvpfsmg91UP9/kC4BWV8S+Qm0BcVMa3JpdbvnEm/9+V4+X2ZX8uLfvxBirNjJfP36Ay3pMma5s6DDwAB4epBvJN/2/JT6/88+mOMu/x5KzrqWW8tkkO8s3E6eTC9iXk5Ma/VOZvS26+5zpqkODoYnv2KCepV1SmtT+9eXfgP8r39qT5jG+SmKuFrBeQn0i5jvyEzZMry92T/GT2hcAfBh33JNvyXvINwXXAJW3z3louNPYt471q03XrtvEgPyFxWfkf3akyv3WjdPeyf9/KAAvgWHVTtzW5gOGL5SJjb2C3ynL/Tr5of3vrN1Pn40qH7VyfXMDYiv+15ATNHpVlFpOrNz9/EDH2aDtn9J2QExC3AK/qQyyLy8XmoVMs0/r9PZRcm+AVg96HneIrr59DLkDfp4w/smzffmV83fI/fy5wyqDjJt+gnUx++usm8k1aq4A9qFSzL9N2I9cMnNc+Fgb0XS6kPJ09ybJbkAuybqUHtQra1v2o8rs5lmlutMo592Lywyu1qukIbEYu2D2hjP+YnMS8VxlfH3g7OdE50Npnk/0egCPKee1P5OTmXh2W2xl446Djnad98p/k66ezgKdUpt+LXBizlFk250ulALOMfwj4eXl9FLlmWbXvkScDv2eGT6nWZSi/r/uwqq+V9vuAJ5ATVQf1MYZqsmgD8oNwl5IfhPsB+f5rrPyPXsPqhWz/Q4MK2cgPSt0EHFbZ/+2tOFwP/O+gY+3zfpj0GpDKQwmVaW8sv4fWtUHX90Vt/8/nl/3/W3JydyX5+mPztvdsS82u83qxz8k1584h39e/oMMyTynHsyeU3+pvgW/NY4z3LEP1OxshN0P/i3Is+min4zs5IXXvQe/nSjzV5oofWl63ajNuR74O/+/K8qvVihi2gVUF/QeyqhnT5eU7/QmVB07ILWm8kdwfyxrHgy4/bwdyk58/LOeL08gPqa4k3298n1w760XklkWGKlHGmufyBeQmJv9UmbY3+ZrmlbP8jG+V4/IXyv69uezjz1JpKYZ8nV27Jojn/TsZdAAODq2hckDerjJtAXBwOUC2On59I7lw9dflBLVN9f11GVj1lPdTydW0W0/TtZppOY7crEb14mIPStNFNdyeapxPKCesnVvzaLuILhdGfwQ+XoPYW7+tJ5AL9ZaQq1p+oHwXZ9PWHFo5Ce9Y/S7rMpQLtuPLxcr1lOY1yE+X/Bn4Uo8/7wPl4md/1mzn9Rnkm5jvkzvzrbZpviv5xviQAeyjXclVm6vJpqeUY8YPy+/g7+QnO35bLhLOKPvzd1SaD2rKQC4wOp18AftIVt2gtPoE26Qcg/7U/ntv4lC+z+PJBTQnkpueeUDbMoeQm777ap9i2LDs7+spiY62+dXj5jPIhUYDT5iRb2oeW/3tlL9blf+FVqf1ny//L62mWTYlJ/1eU1lm3s9VrJ6c2IzcZ8TZ5Iv+6ygdtbbio9J8Y92O573eJ+Tz8b+V/4sbyA+9fIDVE9QLyAUZvwPe04dYgpwcP7KMb0NbszTV76H8L68EFg96P3bYlkPLb+oL5MKqatMQjyQ/PPSVQcfZ6TuovN6WnLC5ofz/Hsla2qlr+S1+knzdci25IPZ95CdIlwPvn+H69iY/CFS9d2k9uPIv5IdoLiLX8HkZrFYT/XNUCkGGYagch+5Ttu/aPn7WxuSHmB7A6smb7cnJud+W7/gv5Ac3/p18TzbQZhfnsL2bkBPHv2P1Qsp1K/MvJheArT+IGOd5fzyb3OTmGJW+bcv5p7VPDiEn3k+b5We0ro3eV46fryjj9yffQ3yUISuw7bAPqueSB5TjXeve+dHkAu6nkJtJXFZZ9hRyLZZt5ynOS8k1rf6F1fvFCHJNlS+Q7wd+Tc0fUqicJ04n39e339ucS772eEzZ3pOBpYOOu0/7onVO2Z58Dfal8ru7F7nJuB+19g+rl0FM2v/MFJ9VrdmxHrnPqveQa+mtLMfXSZtYpkEPek6zH9a4ryPXamr1/3wMOUH761mu/0HkB9lfXpn2RHLtsRvI5YdHshY29TnpPht0AA4O1YHcNMaPyQUMD6xMvx+rqjveTr75OZlVbXnWKsHRtk1XlguXVh8T+5ULvX0qJ6IH1/1AX4n1ZeXCZ4JVbbyv1tFbOdG9ldxcUW0uZsmFj2e0flvkC/7byR2dtS7Mp+ybYkD7fCH5ZqzaTvfG5HboLyA/mbC8nEDfwaqngHvyf0Fu6/5q8o3P/7B6fwgLyE8aLydXHf4aObH6hvK/fDOzfNJljjF/vRwnvkZONlUvxO5Nvth7dvmdHkMueP8e+ca+1aneU3u5H/uwja3f7KasaiLyqeQCxj+TCyuqNfpaHYX+x6Bjn8M2t27En1e28Wrgq6zqb+WNrOq7ZyE56X8IfbxpLMf028tv6MmTLLOInGC6atD7sMTTag7wBCapjUF+avnTwKWVabuQkwCvm484p9mG9gcFHkAuwGndXH2T1Z9qX5+a1ODo0/5oHQ8+WP73v01OOLTabX8hqxdsvojcDnpPO6HvtI/JN9W/Il8TbFuZ3mpeZT1yTZtLqFlCmXyuPa3swz+Tr4EeTn6y9XtlXy8adJyTxN7eZOnjyLWIV5ITCW+sa+w92PZWodf25FqOj6HyRDy5EO9r5CTWzeSCvMNn8TkHkh8CuYPSBFfb/BeWY9IKcrJot/J/983yuS8c9L7qw77flJywuaGf21fOvSuB48v4AlZP6P9LiWOCfP16FKWJ7TK/1gl8Vl3vrMeqpsFfWn5L3yLX9N2ksvye5GvXDww69nnYJ88j1xK9o/zOWtdge1aW3ZicvDucVX2Qzfh6vqznV+QH5FpNDX+MXCt5p9Z6yfcdD5jtttVpYM0n7av3+I8kP3V/bfn/+0v5TV5NqYFDvuY9s3wnff8/I1/fvZlc5vI3cjLtAax+73cPcnPi3yLfr36PSa7Z6zCUfXgF+SGcVnPF1bKYv5fv4Dbyg2NDdy5p2x+fJieqWs1R70Du1+d1rGoK89nkB3RnfK1ffi8fJJfJVZN+G5Fb9zm67OvflM/cbND7pIf7ttpk2WvI5ZZfLL+9vSvH3TeRa7DeTr5++pcZfEb1GLI++UH8x7YvU37b3y3H9auotLK0Ng8DD8DBoTqQ21e/glUFDm8EtqrMfwi587jadRI3yfbsSb7Jf1EZX5988/C/lGQGuRDsVGraOXXb9qzD6u14fo5S06nMby9Eq01hNzmr/0dyoqPVvNevyklp07LM/cgdWA48cVO5MLsb+cn3X5bhLEqysszfpvzfPJjV+0vqaRKwnMj/l3xxfgW5Ob9q9dX7kwu2ri0XUSvJBXADuYgs/2vvKif8P5Kb6XnCFMsHOZmzHfmi/lfkwq3at6FaLpyq1eRfwKoOvk8lF1R8hnxR/71BxzuH7axe8F1NTty3kuGvJ9+oPbaMVwtuevodkhOoLwCeVZn2qvJbW1n+Tx5PvgFYWI49nyXfJL5o0PuxxPsEVvUJcxW5jfxqbZTWBXwruTNKftDgDHJis1VwMZCHDSrxtTphrj5d92hWFSjcAfwXpVbQsA6sKqC+N/lG/ghW1YT6H3KBdKtwab329/UxrlYCdTGr2o3/OrnQepO2ZV9Z5o8Mch9Otl/KMeb3rGpeaSX5xnK/QX//lRhb1w0jrJ6sWa9t+z5WjpdXM4RNKVWOD7uSH9ZpFSxeWo5p1X1xP3KhzKaz/KyFlePp38kPRrysMv/u5H4wTmfVQyH/ICeL3jTofdWn/b9f2e+H9/lzNiC3UHDvMv7mcqzZuG2555MLam8l1/5+GzVO4LNmB+/Hkvv8avWF9CZWFdR+rmzPoeR7hD9S82RUj/bR78jXtw8mN+94MPlBsdY5plrLfsZP3Ld9F1uUc2irWboHkptYfGvlHPdo8oOlBwx63/R4P7+SnGw+DXhDZfoG5bj3MnJh9qGsXpv3X8m1Gd88j7EGsCP5nucv5PKW15JrmlbPh/cjX/NeRn7o8TRqeK9HbtL7LCbpF6hs64fJNUEG3gx9n/fFQvK97tcq084jt5xS7ev68rI/ZnwMLMfRlWUdryOXe1SPw1sCz2JViznfId9/NLpWY9v/xoXk65g/lWPsSnLttA+W/RHkh163pNJHYpef07pPObh8xl9YleRdj9UTZZuX7/HXTNHM89o0DDwAB4dOQ7lIaLU/+hVym8RrPA3afgKr20C+YbyN0skluSDlBlav1n5IOTA+ctDxzmC7XsaqtqHPID+xuFqV0kHH2CHmLcvF2WvK+NvJTzlWLzJfXk4QTxlEjG3xtgpfPk0uXDmdXCX4irLf/4+2Jh7ow00obW1mk59W/QU5KfBdckFW9eao9UTrw6lHR9L3Jjed1Uo2HcHq/e/EJMeWR5Nr6nyobscZVj3x0roAOpm2jsTJT2gdXf5PryvDuxmCpwDJNQSuotykkJMoNwAfYVVB9dPL9vc6YdPqYPXv5JvUVq22Dcp56hvkJ5D+Xvb9H8s54Cr60AzVHLdlIflp1dPIhT+X09ZOOflJtpPLsbLVUeury7yBJ+XJ1wf/D3hx2/T1yDdXp7CqoLR2TW/1YX8cRH4K8FFl/OHkBMOrWFW4dCS5ALOntWBZVVD+dHKh4hrHf3Ih163kwpyjyU/Ct953z9Zva0D7rnU8fS65+dpTyDfuD6vsu7uTC4APJNdqrN3NejlGXVWOT/dvm7ewbZmvAs8bdMx93Bc/Jl/THUwuADi3nCsua99uZlfIU03+tPpDbBXoXMbqNV23K7/3xWXYYtD7p8/7fhHzmCwn14b4eTneHV/+bxe2zf83cq2/lVQeuqjbQH7g79/JyYhdSryvo1JIRn4o5POsan1iZTlm7TXo+Pu4X1rH6C0o/RW1zX9YOb9dTX5g4yM9+ty7kRP2ny7jZ5ITwNuW8QXlnDBBpaZPU4fKOfmAsh+vJ9/33UW+pp3yPM2q2oUXDSj+9cj96v2q/F+cRW6eeNO25Vo18T486H1e+R21fuPPI5dZXEMuMF+nbbmBX38PYP98HvhRef3ccqzfl1XlJY8gn/MPn+X6NyQ383de+d2cU3437c3nj5TjcStJfPCg980stnUj1rwGei35fulAcrPTdy//RxeW7fzsTH935ERPe7P6byeXx9xKvn97eGXeav3XUHlwf20fBh6Ag0N1YM3qiP9JTtxcS7nBH3SMM9ye7chtKh9aDn63kQtOW53tbkEuHPhJE07AtPULQK5+vLJc0H2UGieeyIWq55ELXB9ILoQ8svJd3KP8xn7NDJ8e6PPv5xpKx/Jl2q7kqv5LywXL2DzE0UoS7FY++4/kC/g7yIXTX2WSxOoA9tlbgId1mL4XufbejeQm5V5XvRBj1U1K6+/Csty5Nfo93KfyekEl1jeX/8FNWfOJ6nuUi6aNBh3/LLe5U39ZzyffzLT6//oE+amg+1eW+Qi5AGekx/FcTH6y6yWVadUnsRaRnzB8d/ntnEqu6bFTHf4/poj5rWW7/kputudRlfnbkJ8mW8zqzY0NupbNW8jJ2FdXY2rbts3JNXZ/yBD24cGaTZi8pBzjWk2Xfod8w9XqwPb/s3fW0XVbSxf/TbAQKjMzM3xtX5lfmZmZmRlfmfGVmZmZ+ZWZmZmbJp7vjz3qPVauE8exr2RHey0t+0qy7+hIOmdwT3e0zj1GQhPUjvL0Qk7xb4CrgOXqnDMKqv5pQgGm3UmqNgt+phZAjqkfkcNnMFrr9qATBLzj+Z8cVRM0oTVv/fy9Rs7NezriGSjLhgKWHwOrJPsmRYlST8V7chOJw6CtY577PAVak1+Oe3ANLQRoippDR/B6h5ocVOQ1IZ0562P3NbBf3PPUCTQtiU5dto1aAKAJObQ+jvl6zDiepzycFCUZTU8XrrCh5pgdEzm078/WF5onDY6C6HzOjTHcuZ2+fzsUDDoDVdksnxybDtkLDxU9Tu085m8iOvQpUOLjikinHYz6mDajyo6fvVDSxhGNXtep2arrx/r2HAq2fYyqGy9H1G6jJX/Tk4J1c1SNn/pXuiF9+wHk2P4O2T2j5v6u9H6jdh6nTeI+rhtz4wXJvNgn5v6fSdortPF7xkYUYW+hoPi5KBl19OScXiigfhRR6dmZNmosCvdSS/I6GNEpjx2fe9Q5/+jWPnvIX/UdSibrkTv2f6h69Jv4v6eR+CmQz67T6Ucdes+KFqDaRu4tXeSTffmmwdPGwvsn4uA+pOgFdljXk9t3dExIb8Yik2Z+bRALzNbZtRd9DW245impZRa+hLIZS8mRHotw1q/kY5r3TdoQGfG7l+leIMfX0rl9vZFRcl4odH+TGBAdKMvLyFD6NwoGjIWCdb/GwnsqOX7SBo/VGHFfm5BTcIhgC6I+ewMFw65C2fj1Gu6NjYKpNxT9DIQ8vVCg8UmGbOg9YzwDGTVYs0AHMgBKlxHeimsegq4rfl8s1oP5UOD7b+Qky5o/T4IcZfe1szw7ImfuCnWO1VUuaa70loqOpc5zMkusV6/H+3xWiefyXtR6bGVGW4v0VnQx53T+vlDLzlwy5r81Ebf3IJQ5mFWKzIQc1hd1kFyrxPcPjPvzDjLMZq5z7vQoqNAUc3KhgZuQ6Q5ULTcvcg4umcj4ENLZJixazlZey2rUnFWXoozULElle6R7zl60nO18zekcMBnSVzKHRDoXz45oZTLKvrXa4bvTYLHFM5Qlng2kg6nCqu2fsR8l5rmzQ094GTn5xmppnS7jhqoAPotreAkxUKT9a/5J0KGkNnEHjcsx8c7+TpK0FuOR6onjECwX8blN9z4Z48mSteDruB+ToKrF62M+LW3iYhuudwBK+tgwd3xCxLbxXMxrl1PHaU2Dk92o+ZMmimfjjLg/veMe7YmCbl+j3odTUwK7CAVdPwHOpHllZjcUDNwu5rCBqAdll0s+Gs7xujDGoonEFkOB7k+B/7bx/+aDCj2AqWIN/xElAhwY9yT1WZaOVq+V1zszopB/N8byJBRcub3OOHRD1YaPIEaGVtmyKIHopWyeRomlE+b+94rIXv893s2G0Sl2tq1wAaqt2twdlPm5DM0DGv9kE6HMiK+RI+m0ImQczuvZF1gsfh89lIfPY+LfATlTzkAG9cNFyzuU60j7BqwRE/zB9ZQGYFnkoGmiRBmpDOm82wIF0P6Me3AAcmh8CzzQ0t81Wl5UufJ6KCFZT6TeNDdKxkLZN48DC3WwXCsi588QPWqQgfwqCt48Hs9IwzP+QrFYCFVZ/BTy7FznvKyK7wtE93RSfvyQIn0sJaEwQYZI1oNkEFLe/3FWo2yy/eNz97jGmZFz7gFgp6KvoQ3XfCmwLc2dYZlhdlvcu5cRTUXqrNsIKYDt1msCOQReiXEfkI17nfOyObOUwY5WXuuSKIPt03jeditapjoyzoKcoXvl70Uyhy5KwsHeVTZk+DyDKkWnrnP8ErQWf0Nz/u8BMTcPpAMNf5SR9xLqo/Ugqsh8KfYPETxDukXhehDSOS8m18Q75tcNYr75Azmplqv3/hcg8/QkFZjZdeQ+HxD34AtkdD8ea+O1jZKzgHE5NJ7/b0i4/mnubDGUgHI+baxEzc07PWKbKNnXF1UpXkItkLlB/m/LuiXrWV9kt5yKKFSmoWR9wsg5YJG+vCjKHB6MqqqWoOROttwz9QnK9v4h3tkrka2V6kRTAEcC8xYte4PGZz6UCJDZm/8lob3KPwf5MW3jd6YJRBm19kDEntEU96hT96ciSeJBNv/2iB5qrTpj0B05r/eJd2uX9hrrdriOI5G/KJ/c1hvpthm1+/vk6IALGvMJgNtDrueRnyVlDRgVsVz8B/kpvo5x71KJSMMxZjPE+/858kk8Q60i5o7hXZfiWc7WuZaS7+ZCesJfqFfv+iggUfo1fBjX3hNRcZ5BjUb6V2D15Jx0PTo1xn2olUz5caFmt98f6/DCuTl7bMR+8mjMqx8C8xU9PmXbCheg2kaujTqOXGDxmCg+Qc3NZ69zzhSohG9iauWvZctazuRaNa7niWSimhBxKT8Wk34Tquo4jjC4KUllR3I96UR9Dwpy/BL3aVBM3kM0d6Qc/WDy2VZTozLNzMm9AKpS+Tbux2ehBE1elnuBFLfPYwF9jITXE2WZp/cno77pMAUCNV4fSPSFIGiIEmVnVWTAfEWUzzZwrPIKQl/EQ3s9NYNqqTp/Nz1wRZxzfZ3jhffkycnTDQW3L4/n4nuC5gMFnrJKxDtC6WmilqU5RtHyD+e1zoZo+D5AdAxL5o4vSq3B9OPIoTQVomR4C7inneWZKea+fVp5/gbIeCw8k6/ecxQ/DVUTzFLnnL6o+vA2lGzwYr35vsBrmAg50A/L7U/nxYNQwHKiRsrWgGufAVUIfIUoP7dI32/E6/0YtYaqhyPKvjvQWndsBz9Xk8bc+0Dcp5VQJc0vSI9bl5LS+KAg8X7J51SX6B/PVBNwYglk7YZ0hE2oXy2aVpaMGWvEY7FOnNbZ1oThGBeL+/Qa0lU/BBZP7ynNHZBtnqOpOTlXinXqY+R4u4LmldzjxnP/LPBB0WPUhuu7NMbyJ2o685Ek/Z7S8xskW6Z7To/095uQLrALzbN5x0Dr8dsh+4Cix3U4rnFAzDv9UdLOoBj741FSTi+UJPgXI5ETN97hFVG1/B/Iltsld85wrTHJs549VxkV9fWoh+i+RB+4eKb2BPZG6++YjXz223ss6+zbJ9a5prj+PrG/G80DhqORBEfKMAYoqPYnUd1LLkiLglGvocrZlYuWN5FrabQ+/4B0tS1prteNgYJOV6IAxft00T6NyTvYD/lrNiCx4VFS4qoo+fIetN6uTxv6n8Q7/CCi2b4g1rX9kC64BqoenxP5FLZGwY2f4r3otLYFzW2lAchGuDyev4+A9dLzkH19O/DycHzHOkQCPtLL9kV2y9fILpmN5tSW08Wc+wXwf0WPUdm2wgWotpFrA65FgYq+uf3joYbCmZNhW5JeBChT7SNgmaKvoYXrSie/L+MaBpPL9EaR+akRvc80jZSxDdeULZpHIoV4p/j871CIsoh8qbKLaK5QnoSyxbO+O08hiqPMudQTOcD6Fy13Hdm7IUf05cgg+5lcxjsNdAjHYvpdyJNSNGQL+gxICZ6UggKqiA5jg0SmCVAD7qfjGbiDOj1OYpzny9+DMm25Z6M/ctQ9ENf1cihTA1EV2dOItm5xYHxKYEi18Zqniet4G5Vwn0HzniozIgPma5Rx9VeMwfm0M8cwcj43Ef1TaCGwm8wtmdOwVM9TIl8vVEn2bswtbwPbxPub58s/DNg1PpfiWUKGwK0xry+UH2eU4HETSfVkV9uQAfk2MoIuR47jdJ7YC+lN38ez+wFyaHZ4wAQZ20/HOzAJqjg+hprBdiklaNhMTc+ZFxmL9yGDPE9Jmr4TU1OCPmdIv/mGpP9UnXMsJ/sARhIqJeTUPh3pLd8hp/dUyfGeIzI/U0vUWgI5Ol5DzvTr4n27mkRXinNnBKYoemxaeX2ZHvV/sb7uHWM6W4zrQFQNvk17r7etkC1bxwaggPB3Md/cG2N/LUlwJtaLKQkGhLJuw1pfUUA+0/veiGv+iQb0tizjuKCkvK0QjVdG0T1EH7Xh+J6MRnSyWKv+QklAH8b//xLYqi33rqwbcqQuRfNKm2lRn8MH47pvpXkQuvDExqFcz0oh86HpvaFGDboaonYrxTxMUukRnw9BOtIX1Kp6U71uIuQMf42kX1tX3FCF6p+x/jShhIh/J8ezNbhNOg0KxjQl24tIZ/4tvnNwcizze/0QPz8uenzaYXzzCa9TITq+Z+IaH0A9J/dAPoYPgSVa8z+BjYFP89+D/L2nx/i+FvP3FLn/MVJTALY4tkULUG0jz4aM+ItQtuW7wHp1JowFUB+JJtQnZT9EJ/YcJc5Oo2b4H46Mh2WQondperyzbMmkOw7KLj+EWpXKSSibcJvkXr1MO1IRtUHeHgwZCNwrFtlbkeP+NGTk/I5KvkvFPZyM+Zgk9Cwou2ZTFBBpQjRky+f/rqNlQw6OM0KGoxnSGbESUjSHuqB3oIwTxP0dBNxCQhWBAkr7U+t3cyIlc6YPx31IlZ8pkMH1MnK8f8GQNG+d0kGXu86FkQPsLWSU757NR3F8oVhP1kM88O3+TsR7+T5wR7Kv7jMU9+l0pPCOXfRY5mTLnF2nxVp1Y6yxN8e78SjKuGqWOZrMT4W/N4ksyyKH1WvIiJ0wkxFVXP1FnQq7zr7RvIKiTzxrn6OA7Qm5ua9vvD9TAmM1QLbu1AzpOVAPruuS4zOi7OifkAF4YlFzVPIuTIYCW38jCrQmRL2zO4kxGe914c9/yDJFyLkHNWdUi/MezavrOqVzsRVj0ixTPtm/TMxv38f93Y92pPZCtJk3UsvsXhslNC2TjPsQPZ06y4YSRB5mSBq+2VEiTGavrUVOL2zAvb4EBa6Xj8/zoWDSnkRglZLTobVwXbMj5/KOwMR1zlsDZeU/CZxetNwdPR7x+6QocLgXYq5I5+bpUb+JV+J5bDUtKgrYb0bzIN8NyIG7XHyeAlUe3xf//1y09pZiPRiB8V0wrufBemMfY3MkNSqqZkm3Zb1+lLg1GDiH5sGmXihx5UNKWCWBKkdujTntf3FvPkTJAHMm5/UAJila3g4ag7Q/499x7SsiytOXYkxuo3kCX5ueQxS0eRGxCTwXz/cEsY2HdOcFkX9jo5gnjkCVaHOO6LWWdYtxORTZvFnQ6gjq0DEP5X/siaog6wZHEeXc3fG/74p7PNJUi7bpvhQtQLWNXBtyBC0bi1ITyuKYv855m6IMrh+QAv4aQY9DyWg1qAVsxkFOokPi866oQmXy3PlTALMVLXcrr22NGPul4vNEsYhuE5/nQY7wzygw6wAFE85FfQ6yMsxnUIApLS+eGnGhDkRKeamepZBxvXg3DiGhI0JOt/3ivRiEHMJTNUCefAb7GfH976KmdWvE4vwW8FrBYzchcmJ9gIJzpwCTxrGeyLl/Fsqi+YYWMubKulFTZvPB7gWp9cj6GznkS8U338br7RU/p0N9z35KFMgHyDVI7chxj+2U+O4tcsf/cYjGz6kQTcvlRY9hC3JOE+/AvtQySy9HVYnPxvt9PgqAlYYSrYVrWjzm+sHI6HoYZcr9ApxTtHwNuJebIsflN7EON6Fkir0ZMnutXdc7arrPJLG2DuGwRVmiPyOn+VjJ/qwH3gklGMsr49lZAWXur4qcJk0oc389SkapFOP5KuF4yq8Jdc4fs6NlKstG/b5JvVBG51NIL38XWLgdvmt+5NDcONaI7vG/L8neBxSovItOlD2avNuzoKD+E8mxbjR3pq+C9L8mGtjLDVVTfowScjLaqmuRE27i+Nw/1oS5ih7T4RjzeakxBPwea9t51K8S77S0XMM5JrugBMJsTAaiIOyxNKfXWRDpihmd1zDHhpoj+DxUNdcXNTs/mCEDwDPGMzaQElSKttMYT59dC2Id2J4kUIiqZJdBSbd/Ij2j1LYTom28Gem5ryObaI24rz8AFxYtYyJr9oxvg2ycnQldCTnP76Km1+1BSSqEGjAueyLqs0mycUKJQEdQCyIeQzswpcQz/27MKXeiAEIpA5LtNLbZMzctonfcFliepGIWUR8ujXwLX6Ekv1ZTxiN/y0Bgk2GctwZKOPs55tYhkhSqLcaqaAGqbeTckJG/GTUasf/mX1RkAC0GzE2DS+/beE13IsNlhvg8Y0xChyTnDIgJ8Jmi5W3lNS2AIu3ZonlGKEBTxeduyEG2B3UMigbJ2Bsp238gR8suoYTeTfSfIEeDgcq+m4Dtih7jOtczHnIifUv9PizzoX5CTcCaHSRDOlZ9EcXW5Mjx0Qs5Ch+IBbkpfj5OCRrHxTM5E8o+z3ow7UjNiBuAnHJZZUHpmqy34honY8jATS/kPLmOWnCj0/IdU1Mqp4l34WpEfTcXCsa+hSq7LgMWaJBMU8X814Qy4tJMz6y6YAAKhvwNzFj0OLZwHcegQMec8XmOuKYNkRL/OLXg2J4lkDdthr0EMjC2IipKUAbulsjB/hrKel+Rkgec2mE8VkUZ/UfFnNcPGUAvo8DbPSg7sMOy3+N5/x05FF6NtWtH5MQeAxnaK6MKrv3IGX0UVIVMLejVDWUUHlrnnN2Q0+cPxHXeZtqddpZ9iXg3f4m5ZqiGNMrKvQRVYrZIpdZZt+R9mA/pqC/FPLBHzNmpU3eieF8+JFc50sbvnjHewZXi8wHIKThbcs5OKEBZuH40vOOKnGNN8R6smxvLNHAzOrm+cx0smyFd+WMiiYJaf9Q1kvd7OaQrrFD0eA7HtT2DaM/WRMHtI5Cj/KeYQ/sULWODxiG7h1PGHHwJapo9AaIGvRPZHneR6Frp3N7K7+mHKjKa4nk/DDEbnBbH/6kejc+jx724sOgxas+xjncqq+64AlGhp1TYEyAdPMuO36sMcsfPviiAOVnu+C7xLn2XzGOXU7Kkthj/p1El19ixL+0Vth0KmL2N9PN5i5Czwfd0Cer3mh0V0fldiPyH37THnBjPzwnI3vwq/v+CyXGjkzJXtDC+/amxj2T0b3egytpxkvMnQIGdzYbjOwzZBu8Dl8W+FscOBYgOBV4venzKvBUuQLWNvBsyJGdE3P9fogj3nmVbTFt5LWMhR9HGNOcmvRx4I343pID/nU1+dALaNGoUA6Mjx+ndybFpkTNmvaJlRGWst8Xic08oQMflzssy98eJRfms7N4UPc45OfuhoMj3wLL5ZwU56Dsky4vmhvjeyBGXKYvXAIvEsYlQdvW6KLutbDRQvZARf0sodk+TGO4o8LEZtUqDUj0DuWvJnFILoyDF56FsnQAsQnNah3GQU/tZOlFm71Cu/SoUKJkxt382ZLRn3O5n084ZOihANC3Ng5gLo4ysJuAR5NidmFpw8yyUJVt4BUEL1zQKogC4gRqt0t0oG3mc+Lwsqjw4hWgGWdT7Qc3A6IecM38jB873yGl9QG7O6k8XzpDLjc1jcd+yaov0OT02ntGMumnWDpJhb2rOkIti3XoNOcUHxzvyePz+JbVAWxbkLHTeRQ78x6npAt1p7pjuE3NLEyWpnIv55+m4r3/H/LfGUM7vg9bBJmCWouVv57HI5ofRUWDk0xiXy+N6n0EOh/ForkMNF7UMLTgc0Hr7BqJGHg8FcA5K5tYxUSDpZRrYg7CdxrY7cpxdhILAbyAaynFy5zVkvs3PFTG2HwDnx+cX4t5nWeq9kU35IQlFUpk3xMTwCrBRsm90VNF1Dlr73gTWKlrWBo7JWcj+mCm3f0KkAw8GDo99w/Us0jwYMzOyZ7OA+Js0D75mtkKfmFfuZzgyz8u0oWSo/1DH34JYQn5DOtbx8eylc+cMKDEj8w0UpRtmdtFEyDb9DNkKNwArJueNibL+Z0H6fKlsPeQb6oN0p2dyx3pQW+PuQuvb63TBhKTkOrP+Y3vGmrMsdXxlaO3dghzzQSu/ax/Uo2WmOsdmjWfoVxTwP4IuWN2E9Nq3UBLulIh28iekU16GEh7apLNQY524EK3RPfLHWvi7wntFlnkrXIBq69pb8uJ2Rw6whZCzNFUARkNO3/ORc/h1YNX8/yjzFovuJJkClFz3AsjYmR85k+4CXiha3mFcS4tKL1KeByJn/WgoI2kgJXEEoMzeDVGzuix7YBNy1CYoM/t14JqiZa7zHGWGwWxxHU9So/hq1rAwfdbaUYZMEd4bZSfdiQIzV8d47k0JaeWGcj39UDD1eWTcXUOOnrDMcww1RXbUUH7eRcb7MYiO8VVEpTcbiQFJF+CGRYbMXSSGDArG/UMTF8/nByi7eQiqzRH47lGR4foC6lEwfnJsdFTtkzXH/I1aRvKfqOdTaTOyEFf0mvH7dMgQ3Dl51tZEVbCt5i/uQFkzmS5F/Sh2js9bxnjvkD0TnWleaodxGYAcTI8m+/4ZA1Rd+iDKGvwGGK8DZDAUxDw+nv8PkVN3NlTtuixyqp2OHJEPUKJqA2qZ+V/Es5X2AupBYrAiQ75wDnkUJP4ZZZxPFGvbE9R4wVukgcqve11hS+aHM1FW5zLxeRpUAfYeWvdvi3lvjDZ+z13xLKeZ54YypI+O8X8dOUHStWJd5AjZseixGoExHhf1q3kh1rwr473v8IoPmgfkJwhZJkru+x4xv12FnGwLJOfPi/SjK4oew+G4xilQtXT2HKeB+DFRBWlGL75r0bI3YGx6oirH13P70jG7EAWz2qTzxjucjvNqKADchKr2NiChYAL+DyVNnVT0+IzAuB6QXN8mdY73QT6ZJhS82o0kCQzqUzUXdC13Iv3/opgHXkS26w35NY8SJ/Qgm24gScApd/wkOpn9PZzXn83pR8T9+z6ev6dj7W6X647545pYlz9APZuGoI9FFeLPIPvuUWQjdYlgWcx555AwAcX+3khfb0KJzf+hFYl7yb2blOY9pDZF+tf/1fkbQ/6ZuZAPY+Oix6XsW+ECVFvX3ZJFfbSYHP6MieB56vexGR/RfdyHDIP7KUkwYFjXmHxOm712j2t/HWV/bRPXP1+cU6qFl+ZKcDdESzcFclBmgYTZkfNlIDKQfgVOKVr2/HWE3LshaqwfkVNpQRQ4GxWVYf4FLBp/UxRFyxCNvnPHlwv5H6EDnG4tyRPj9APKyM+y7/dAzq1Z43NPoodQ0fe8lc/EJCgD9qN4DzuFEyWZU05DCubi8XmceP8yKqQnUeXQNEXL3M7XfwoyyOfIvS9ZJvMZyDhbvJ2/dxQUAH4y1qNrkJM37ZE1IVI2L0BBzX0oIXd+vbklOTY+crhnmar94l3/iJJUz6HsyJ8Q1UWWGHEpcjhkAe1+qMJsQNHyNnBcTo05YJF69zuO70cH9zMBxkbOxNtjbr2faAyek6dh/S6GQ/blEK1eE3Lw70bz3ju9KE9VUBZIPp4a3WdGB7pfrA9ZT7MJkr8rbQC5ncZlYpTMcAC1PjKXoYqvWWOObkI6zQ3D+z6gZKCLYg56H9igzjnHoUzvbxEd2jqot8anJIHVzrzFercvqpj7DjnXZqODbJlk3uiGEsQ+Q7rAQyhY3xfZWFlC0RfISTQ3Chg/Gfs6XHdup+vdP67jD+Qsy3S/fKLWZMDmjDw0adn7uwjNgysZc8Lu8W6PkL8gP08ifW4gNdqgPZEN8QyqRO60WeEo+Lk1Suz4Aa3ZQ/T4QjZeVn10L7IxSqEXJvJ9SxJ4QjSZJ8aa8CVaLzuMIrYdr2VGpHd/AKwe+7I5cBLgJuDeouXsoGvPrnNm5OS/BFHCHYF8aANRG4V2qZhEPoENUaX6TyjQt3kL5+2O1v0mYKGix6odx/wI4IL4vRfNk5Smo9ZLqdUV5nGvXkLJ0v1jrfo25tLeKOF7OdQv7OZ4P7ME63ZLuuyqW+ECVFvX3RKF8+yY8M6mlvH+AbVAwIDkbwyV6W2NjIKti76OFq4tdR72QJHiug6JmJy+j4nr6nRsyrRRq7BYKxS5H2MifTwWrTHj+KIxAZ+KDNNSUj4gp+ts1Cq4vkLZUU8jWpld8/eyABmzd2RjlEGzEaLYmCw5ZyVEDXB29q501PNDTXFaM97RJeLzlDGGe1IzlNZDNHSdwiAOmbujwOOVBFdtkfd/OOSeAJWJH0rNKXVJ7JsYGVJNSPl8gnBkd4UNcRc3hYI3A82N9lERvdHNdJBjEjmqdkfOtx+RATgbicHeUd/dTvJn73Q/VJ3SO3d8NBQU/g6Vx18U13lCHC98rUIUPZ8QPROo37tgG+rQ6HXFLbmnC6GgzTPUaMeyY+Miiqh7OlqO5PMkyJn4IjK8r0ZO89IkqLQ038e78XbMoXfFGliqtQHpB69RS5xI9dBR4nk4A1XifIWCB72LkLXB47IIsiuy6sFp4/nbOD73inXxfuDWNn7HGCgQcFv874dJqsZQ9cdW8R1Zr7+fUfZ0p0ikoGYDjI6qCbZFDvN5iUoDZKPNgvTRP5DTZaIOkieb249CjuWnkN7zYcx7uyQybUmtOiLbHgZWLnpch+N6l0FVIx/Fs7N9csxorvuUam7q4HFZIN6pB1HyTp6p4wBUbTVhB3z32ChBJHum3kKVdeO393c1cDzTdWM6FIh6HvkoTqs3jkjX+iTGYAhKqQLlH4CSRebJndMN9eS5HNn9/1CNl3lDrCxZT8m7EA3dztQc6J22T2krr38rFJSfOj6Phmz2Y+L5/Br5Idrl/UN68oFIr/oJUUUPkQCI1vfdix6fEbzWbH0fD1ga0SA+TOIvIElSis+rAbO34n9ndscuMRcPQvr/aoiq/bN4hn9O5tKP0Hq+FSVMdizjVrgA1dY1t+QFnitezp2oZStugcptd0RN754GLqZ5WXsvYNqir2Mo15dNfmvGAvM9UipvQAbk6Mm546MS/d+pBT4Kd4S1cD1TI4fdgyjjdC2UuXk3iSJHiaoraG7IjBPPXLrojBILVNZ4/odYSLrn/74g+UdDCvOfyYL2MnIy/CfenefjGduhnb87e08ny+1fPJ7neeLzjcgRN1FyziGo6qpwCqU2XHdpnewtyDsXclhsGp+nQo6jLZJ59d5QioZo3NjZNxTE/xk5ZbYH5kF9xLZDSvyp7fx9eWd0D5TNfgZyVL0T69eUNHcglNaRgmh6mhCVxL9yx6ZAjomMx/y8ZG4oQ1B71hj3FePzSzGfD4jPvZHh9QpdKGDZyjFaLp7HvxF96YrIWXFezBGbNECGfBLLTChZ5XNkCB9OBzl22yIn0nOOJKG8if1joKDsNyjocT6wWNFy52Rs1pulzvExgVVQD5u/UPXQokXL3YH3sjvK6DyDqIJENDKvkPDQo8D0P3bICHzvhDGXfoYcEyeT0ObF8UlQctNkRY/T8I5n/H4J6umROVcGI91iqeScPsDywMEdfH+nju8/CiUe9ESO+zfJ0T7G8QVQElSnbNQdz89G1Kr/niGppIznvbR6Rjtcf117DNmiX6PkmX0QPeQkKKHmS+DMof19K753XGT3rE6d/m/xzD0Y9+T8osepHcY5tZHnQoGCn+L6PkEVdfX6iKxTAtmzuWEr5Fv5hloSXk8S+w6t6VkgYPKiZa9zLd3IBfVRtcnBSM9tQrrdm8CBRcvbQWOQ2bATIZv2sTrn9Iv38wrkm/iApCJ6OL5r/JhLdgNmTvbPiihWP4nn6bz8fenMG83X9ywomG3PAevn5oTebV1n4h08Of7356jatQn5MI5BftNCA7+ddStcgGrr2ltMBnfT3HiaDxmTnyNn8GvxQv9IOCXLvFFz9k+CAgBPI4fRDsjp9SNynsxCrVHf0oTxT4myTpNrypxjN8bEmmVyzhYKw6bU6IhmKFreOnL3RU6YLEPta2TEz5KcOx4qh/0B2Lto2RO5LBa5SUMpWTsUhuuQgfIhzTMId0CG2wgFm5KxmwcZiLMlx2ZATqvdkALZFIpOVmUzVbzXdxQ9fl11o2aY9Ij7fQA1p9SRqKpg6uT8W4l+H11pS57TZVFPjEHIgf9n/P4UDQrCoWSCRRFVRhOijViVkvYPStaqAcgR9Ewyj1yWe376o0DYVNSMqIYF55PnfZIY07QZ/Jgh+0Mok+tXpEdkz8acKNB9YdFj3qCxSum7eiAH1rk0pxr4BjinQBlHD7kuiPf1NRRkLbwyF1UQNKHKmg3yaynS3TLKpduKljdkGup6z5CB5smQs+p9ulh2Ls0dEIcCU+WOH4V0prHj83RITz9oBL4zYwZYGAW4X0/etR+Qk7NTNiWP68rWiqwZ8VFIJ10C6YFvo0DOdkN77tr7HqNq7qeAKXPHj0SBs+OAY1GF6GkoK33DTM6Okq8B92NGFJB4I56xyxkJEhKS+74vCr6NnazziyEb9U8UyGtCDtxbqdkmrbaLqOk5/0JB3cwP8XO840OwCKAEok5PkZS877uhAPfdqIfHYYiJ4geUVLtyC39fdLKjIRv/M+RPeoTmwfOeNE+oGm4HfwfKnj13ayAbImMB2S+7hpB/TJQAs2T8XjrfUTuPywexxnyOGBbqBQ3HQ/6og9vw/5dDlJlpwOIkgnI5zlkG0dB9h3SnfegCNJTJvHowqljaF/l5jkO2wtfIJlwk/zfD+T1p4GdqarbyF6hCql9L51dbK8a3aAGqrettyeSwWrysq+aOX4MMnoWSfVuFovQ8bWwUWsB1Xo2CUnPF59lCebg1mfB3pANKttvxGg7JFFNEwfQiKv3OAjSPIkdpZvyOgwJThWfbhDyZMn8JclhdEgv6ZdQCDaniNgrNqceKzCIf6ncn92B+FPTbCDWC/YhcKfgIyvFCjNW58TlT5g+K5/lH4IHk/O5IufybyG6qto57NhCP75y543vF8z5tfM6cUicULfsIXHMaYFgBKc6XomqzjKZvVGS4Hx/z1Nq0syMD0aysjJxVi6Nqmtlj7pg4zpkSZbO/GXP9meT6ipRpQwHgF1F/oL0Rtc0XyEA6mJLwfaOsw8uQLrBJ7thcKIjdhJwKo8T+6eP6fqYTUTUO57ikzqXLkJPlkVjf+saxfqj5+gqIT3p6StA0FTndVkHZfV9Tgipj5ABZllr17UPUb5S6Jp2MtiG3dnQjSZjqKhs1G2M/wsGTO75D3Nf9Yy6/DgUO27RWUNMzx0QOj2uQXjYZysy/DOlDL6Mqt8Kf8TZe56jIbjmd5r3besYaeEuM69INur8ZNer2yb5sLjw0jn2Heldk1Ia/xv4nix7P4bje8RHd8A7A+sn+7ig54QRq2cpD9FPqKltyj3ui3rZNqNpxQWr64Vgo0exA5FBdmhqDRauTTHLz5DvIDloX0QJm68Jg4LCix6UDx3s0VFl9Ms0TQSZF9t9vMQ7XkzChlGmL+fbWkPND5BhOE34KTxLJyZs9431jvnoJ6eNXxecPY74bgyETMTplALqV49ILJdDcnc3fMf/3rXNut+FdY1HlyLvIx7g5qrrNEi/2zZ3bk6j4QUHhJ+hk7BwtPTeo0uVUmtN7zxDP3y+oMvtoRoBmOu5P6ndbKv5vE/InbshI1Hu0Xe9l0QJUW9fdkoX0cSJbA2UwNoVylF+Q9otjMzdSzjZe27TIYbc3tWqau2OSnwRlCGWR/M8oATVInWvIqOvWTPa9DhwVv6+DDNHFE0VjUVSOvFkJ5M9kmgMFF1L+51ti0Z8sPo9BSZtGoizx8chlAlE/y6QPyjp8nRFoBknNANohxu5l5FBLKfDGR8pk1nT2dKRMPogcJWcXPXZddUue7Yz6YYXc8fXj3T0L9fK4DdEvTl607O1w7ZegQOGXyJgejAzLi0nK1ekAxxjKMszm7W9jTJuQw++nmMvfi3fwWWQAZOfvXPTY5a4lczSugQyPNZJj/VDG+OUh+4vA2snxhtJfJrIejYzWvVo4vhqid/sTObFeiPnrDWCLose8g8YmNbg+jrn3zljf/o5ncUXqOCcokZGPsu6mK1qOnEwToQDX8zHPnEuSrduZtzLd+466LuRsvJA6mbDIOfFDzG8fEP1PRvC7/4OyovNJFBOgBK1sLbiXEWyKXtDYThrzy/HxOd+YffZYCxui+yHO/T9RotLW1JLHxoh7e3HMK71RgGMSFKyeixIny8U1ZMGntVEQPqvY+jvWttmTc/uh3pY3UGLa8HYcm+WBc6gFDX6Od33q3HltnuMSnWLHeOaXTo59iip6rovvf48kmNZZt/x4oWDY79Sq0nrSnG58Q6QHf4b8HaUJRjMkBfq2SCf/GTnZVy9axmHIvzOqPp4zPvdDwcgrEYPAY6gypBQJVQ0ak26xBu2EaMp+RAHrWRnB4BtKfvyA5m0YJozvuQ8FMJsxmCAfyIl0ctuCmj9h9RiHS+PzqDQPrixLreKwTb3/ct/bPfd5t5jT/0AV+MsVPTadbStcgGrruhvKRj4qFJ7vUST3DZS18U8/kWRC2SEm6VJxiLdwbXOHgrBKfJ4vFtpVknPuQE6A/YqWt4Vr6IMCaq+hoEEPlEH4DjJ63keK84A4f3SU3fQlJSrTR4GztwkjB5USN6Hs3uw5OznuV+FVXNSMtaVRoG8wyg68E2WApCXe/zQfpUbPsRNyIA+RGdzK709pt34GjkDZSgPJZZUhY3grxGf+Vcj5KqK5KTyLuytuNHdKHRrvZN86x3ZCxmYTCuK1a7+jBl9z9p6ugZzwexKBbtQj7DrkvLmbWnVRuzol41n/X4zn+6i56TqIqmsXVJFyFgpk3okCw6+gLP3XKZFBm7uuM+LdnS4d6/h9alRNmTkb76bB1SrJfDQ5UuYPStacjPJkVFRNNi+qpNwbUeLcFu9Im7PCOsuGgrMfEf1J0Jq9IlrDByFjfy46MUVTg8axO80dPt1RpuGR1Pj896zWt3JuNKfLPBu4Jj5nelU2n/SnVnk2WTt99zHIlpkgPvfOHT8WZfN+SSesiEA6/hfAXbn9aY+Ih1FCXocnQSFn7OKx1g5GAepFkF31Ls2r5rPnovBebK24rkzGUeN5uhU5bMemxtQwD4n+H+d3WQdu8v6ughI3box7vyGqEP4p1r/tUHCuzfoWNX2zF6qqOY9obI4Sd75G/otJUWZ4FjzafkSusSxb8vxNEdd2Vu54pnf1i7nseMLepMEJPUO5hiH0HFT5+J+YG75G+mxpdMPkuTNkWzxQZw3piwK0TyGb51aikmxk2WLenwnRXf4e93OHeF7bQtk1Tby/myf7MiaTB4C3cvNss3m3K2xIx/0bBaQfT9eSOs/gnsAyw/G/h8Uak+rbfZDe1gRcXvS4dLatcAGqrWtuNHcu/h/K6P0qJo0ryPUAQJlT56BM0lIoBcO4vtFiEcmUm5NRmesU8Xl0xMV8IDVjojSLQKK0rRqT5/rxeS4UWPsEGRMphd1qsf+0MsiefN4E+Cn5/Bpy8vZP7sVZcT8GFCx79iz0jrF8AVWYrRPj/Tly0q9Erkly8j+yhuJtqkhLZDgjFvC5kPH4KDKWMuMlXWjHQIbS5JS0YqmrbMn9WR0F1G7I7W9mxCMnRpdQ6lGg+xFqAZv0WndHjpsT88fa4XvTQObW8W5+GO/ifMM4fzRKRsGQk3XXmC/SvnLdk2tYHvWL2SHmgxfI9Q9okJzHI7rRmXP7+6AM4yyw9DZS+icremwbMCbp878RcH9+XUANlLeP5/VbRH3Qoc49WjDSKJHuRs55G8/RXMnxPOf92Eg3/Tmes92KvoZqa/HeToOSTD5HtKADkmMd9gwi6swmmlcldqNmB2wcc9hsRY/RCFzjTnGNZ+fXAeQUfYJ2yMIdTpn6xdhmFXFNKFjfI3deaQM1LVzXwTFvzxuf+6DEqH2JPgtID1yvaFkbOCavA9fSPHltdKTnPhj3/naSPl3DeueTNWAUmtMCjYkScC6Pz71jDT0kGf/tkU60eWd7vpLr/BdK8Oif298d0c/9hZJhBuSOTx5jvnIJriELeEwZc9QN8Zwsh2jb07V8fkSt/CftSCXejtdyOQooPZG/J8k54yIa7C7ZNza5n/3jfi1AjoIPBbAWQclZf6MkueFmrYl3vAnYMbe/FwoEH5PKlBwvjc+uHca7T8xrz8ZYvAYsn14rI2DHDmtuRIGw1Kc0K12kqr2h97FoAaqt6275CQ/xr9+PqmlepTmd1ZIoy3ab+Fwa47+V17pvKHsTxue5kPK5f9GytUL2m1F1TdavYT1qDY3vR43KzkNBt6cpiNsTNcgeIvs1Fvw/USby7ihzaO5EKZgrFqiM8qHIPjaZ4/0ElM3/r/jcA2WS3YeMts9R1ubCOWV0lHjWTm3j92fGy9Rxf3ej1htik9i3Tnp+Mo59YiwHFP3MdvUNZfg1IWPqPWDW5Finmhtbca0W26goq+zZ3LH0+b8WZQL3bmcZRkVGw67UApQXIQfupyjja47c32SVb6Uw5FEwdwgDFTk4v0NB2dnTsY2f66PMqxmpOSV3L+AZOBd4Jrd/NmoN4R9EAe6M6/64OKdLvQ8tjM/BiNbggRaOd4s5/Uzg9Y68T8nv/VBl3Cqo6qGUDUWTNfeQeG4uonm/jl7JGrcKoiVZukTvtUHrqgcQnceS5JKiusoWz3k31PfsWETr2IScOYvnz2uP5ya3b5SYK79Czty0D0RPVAXwIlGJ05m25BmbHFU5ZPr/9kgfmTbWwYHAwkXIB0wca8DriH//MMJu6WxbXM+JyHGb6eCXIRqqSZPzboy1cbQi5GzwmEyO9Luz43O+InIxZGf/gqpLT2rtWMfP0+OZXjY51pta8/dl491eOft+FCC4hU6cGEXNUXsisuHSni8zxfv0K0qcWSjm116o6vmf3qVFrYk01zseQbbyy9SCuFehqqy+ub+bv+ixr3MtYyPmiu/jnhxBy4GbbnTxymmk3/8RY/ElYuJJqQq7xZhtDlw4vM9NzBsnxv/+GtFvLx7Hd0SUlLMXPQ4dNLZDvK/IHjwBJSZ+E+MxY3J8mP49ajr1UkhnHm1o35n/W5KKs6LHqLNthQtQbV1/o7nTrT9yrL9EzUm9XkzUHeZs6IBryld7rBCLzq3IkHghJsTR651f9EZz2q1M9n2T431Rxu4bKIDwdVxXIaXGqCz2exRAGi13rDsydr5CpbQXUCt9nSyu4zdqzSoLzZ4IBeR/qIy7f+y7EJXojoYCTp+FIvNtXqGI621T4Iya8XI3Kr+eMjnWM2R4hpyiGM/LCijQtGDRz29X31AQYQuk3DehbKCVcs9Ap80Camk+DGXyL2DJeucjCqNPgOnbWZ7D4127laCfiv0LIyP/t1iz9iKhD6MkAQNgZmoN1fvkjvVAFZ9/ION9W2qVTLMgg/e95Px3UXCs0X1tTo/5e7L4PABl2DUh58E4sX8MRGnwK12YLiYZl7Hi2RtELtBe59zedCAFKDVja2NqfRiyiocnKUm/BUSft1hu3/yI3uqrmGOGSKgBNkPBwcL7YSAdbPyhHK8XVDg87sneRcvfAeMxRFZmzF9nIl37a1RR3ayicDi/o8U1lZq+/G+USPE3slu2RAHTfVGA/7qix6qdxntPlGA3kJpT7VvgPwXL1R31gTwv1ot3UMJR/6LHrA3XciTwbfw+b4zxhtSowqZDQeSRon9k6CrvkiQnICdfGry5BQXudonxOo9WVP8n4/sjcvifQVJ5GefMGefsGp9nQDrI40WPzQiO65jIfv8d9fXYLeas7snxc1Dy4w/Izvsu3v2L45wikx0zOQ8MuTaOz1OgxKrfQ/ZTUQZ/qQOcKClsPWoJSDfH89lpbbrhvP5sLd0Q6WInI//CFYht51vkE5k++ZuejEDCcMylV6GA77soAeEXYJ+8XF1pi/lzZWRHpMHPxZCd9w3yLxzCcASmUVD3tRjLw/JzabV10P0sWoBqGzk2huTmnRbx1H6IgjdNRPYWJczYbI3CEgvQM9Syglcp4/WQ8NXGz96ICuENcs4KxJs/PrkMlgKenf6IduKi2Dc6zfmsx6CWkf02cgDuiTJxviCahFMCJ2s8+w9QMwwmRQ65bQjjAwWhrmdIruERVipQZkQTypLOnOFZ1UDWiH3p9PtQhuMDwEtFj19X3WKMV0bZfgugwM0AZGC9H/flFhLHaNnmllZc4z8Z46h58+YkzhbkWP0p3tsFcn8zHsoKequdZdoCZWEdR1IenluvNqWW3XsfqmoppOJwKNexPbBV/D5DyJhmVG6BAt+DCMcIcnT+RdD9ICP4eQqgZEAZoN+hTPXTURCgiTrZdchR+wG5xsRdcYt3ZSaUFfgSck6cRoMp7JK1YDzkKLkRWDTWrzfjvk0f5xS2zqJM4aYYq4Nz82XfmF8vQ073j5DzpB+qrrmPpNKv4Pt+NUqiuB3YA/WWmxxRwQzhlEIOz2VQz5F/FS1/Oz5vM6FgzD9VwPnnCwVSbo357V2k+7WJxhUFBa6MMf83sEjsT2mV+iD75bd4jjLqxseBsYseu9ZeZ/ycAlFjXo5oZHYnAr9Ir94NBc0PRtWYpVj3UNXT8tT6Qj5PSashkF43RDAd9a35Icb8CRIKZ2SXbRzPWMMrmwocq+3ifp5Prr9ezH03o4qQsZA++DMwUyv+70woGe43lHDwAwre7E1UJiIH59Xx/U8gW/IPukiiGrI9r0nmqnWo9efqDsyOAh+3o+THtaglnhZqO6M1+i2UeDFW7Ds27uniKOiU9fc8gpIn9KAgxIwoEezDeC5PBCYvWrYGjsGpwMVEQlbsWwJR332LdPwDaSO7R6xdu+T2LRfv9iBk+xxMcxu0SwVukI3dhPxJC5Cw1SDbYmOU7DcQJfIO06dAzSYfCziJWp+c3SiJftBVt8IFqLaRawulKI32LoIymc+Kz4VXpFAzFsdKF9DWyBaKxfitmfgKurbzUXnx87G9hRwXmdH5IDBn7m8KvyeJLFlw4cZYeFfNLfiroiqW75Dz9ylgjSKvBRm+y8biOXnsW5kw7pFz4F0SwyPu04HJ53ZTmBHl0JHUaTiOKOh+JmkQh5xBW8XzMWd7yTGyb4niMxFyMv2evId/xXO8RcyZUyFH7bdx7Dg6YW+h5Jq3Ro7eV0jo+OLYMiiAPAhlUa4e7/VlyGG9cTvK0x1lGp2evQ80D9akVaIZJ/DnyMC6tOh5vqX5DDnffonrWjTZ3xs54O6M+fNqEr7yGOff2nOMh/N65qVWhfsNMgL6x7Es+3gM5GB8uTO+AyMwNn2B+ZChm9H27USDHZXIgf460bcDca//hRy/WdLBchRITYKM07uRE/8BlBCR6gkToh5B9yIH3bfI+f4T0XC54HudZXy/iJwaH1PT015BOtzJqMJgFZTEklUXl1L3HM7rT3uG3R9rxeYklUcoqWHc5HNvVEX4ZDyPj9MGjna0FjfF8/AVCuh/gfokXoYC+HPF+zhefOdy8W4OKHrsWnmNmY0zdsy3A2M++SSu/VOCqrqle1OWLdaDXYEzi5alBfmyHpQ3o94i+Sr2U6npfTtTo9jeOObZhvYPKnCcsnd+wpjzfkfOxC0RA8H48W7+BWwY5y4d47ZiK79jsZjzD42589X4nvuADWK+mQgFBh5GduZaRY9NB4z10igJchAKUC9KUqFNO9MPt5PMCyOfRXbvx0L2wO5x3yZBmf/vkFSOF73R3N/VPdaNCZN9oyC993Sk172PAoldlhYtedd3BK6P33smx7vHOvtIrE1PMpzBAFQJ8jU132Lv3PFtUMXsT6iabvWix6WDxnpMVEH+OrLtTkJVR2mC4jgx523Yiv83RFIK8ik9TvQGqrYOvJ9FC1BtI+dGc8eYUeP0LbwSIpHrYeT0X4uhROJpnj2+LHI6li5aD8wRSup9qAz1SsSVfDJwAKq2eRcpwedSIl50asGa7Oe2yNHya8i9GEPy9PZNFR8aaGxSM4oz51FTsh2Qe/7XR9lci8Xn6eO5u6igsT4dObLmj8+zoODeFUU/B11tQwGZS5Bz8ULk+NwA9V34i1ogdY6YX1ZCJc1NKMOs0yj2yTuxKHKCXUVzp1t2vAdybpyJnEfZe/MhcEQ7y7QTcoguMpRzUqOrJ6oQugPYo+gxTeRaOL0GFOQ7HwWvX0ZOipmT433SMY/fN0B9b54s+jlB1RupYZsGz5aI92XPose9g64/T706gOYOlf5Iz7gROV0eRzpKhzvrkYPhWpStm72vd6AK4/GT+/dcrHMNCyBQqxz4F7WKn81RAPjLmG9WoTnVzhSIluNQlNE5X9H3P+Tqg3SwgUi36YkM40UQheRFMSd+He/4LzHmNzMCzWTLsiX38lTkxFozOZbp26fFGM2dez8mjr/buo3fvTrKsN8f6ZHLIOqzu5FN8HvMPz+gtfk04GhglqLHbTiuMRvDq+P9WDM+TxNzSda4+TwUHCudPZO/nkbONcMp21jU6CR/j+dlepKeeMieeQ05oV+mFjy7nxJQNRYwZn1QYtlnSA/+LrZBwO3JuG0Rx5dp5f/tEe/yX3FPuse8/yWyJy8lSUyjRP6IERzPer0tesVz90XMZf9BdkYpbIpkjsr0jGljfZssPh+OAjTTJX/zMLKhCmMGGcp1LI2SjT6KMb+V5n3YxkHB/3uBT4uWu4PGIruXvZHutQnyR2UJrD1oHkwYF1XVbdrG77sOeC13H1JbIqsU+Tbuybl0warGmCsnQ3ru98jm3REFqIdr3Yxxuos6ffuoJdaVWl/ozFvhAlRb19nyikFrXtwyKkXJ5H4Yikz/hoyXRWnu5MoHbxZC5ZxnNUrW4byuupkKNM9qXAhl0v6MlOS9yjoBx0J0AjJuPkZOotnK9HyhLMa3Yhz3pRYUOyD33PyOnG/Hxc+fCfqbRo9/POdNwFExxv9BRs6Aou95V9kS5fVolO0zRAAAGSlXxb14A5g79o+HqrM2Lvo62njtrwI3EdRWLT3fKIN2CuSgXhs58tvNIRnP9nHxTmYO55YqVwwZVZfn55gSPEOrxDzzGqr0TNeoxVC2auZg3JbmFQfZ3D8ayja7lxI6H5NrXTDkfLlomTrwWjOH9cLAf6k58c5Nnz1kcG2EnIG/0AHOFuo0dI934Nn4/d8xP62U3KPZUJXgoQ0cs1SH+R5lZGfyjB5r2Bcx155CCappWnldl8R7PV9u/65xz3dEwdb94jk5vGiZ2/FeToGSWfaiVsGVOQWWpVYN8yFaD6elnRz31Kptds/t74vW5C+QM+kaVI3TRBJY6gxbjO83qPIyn4U8HXJgN5HrDVVtbRrr7qgS4EDkIPws3uGsqmYURE21K6JIOzfm9rGKlr0jxyR+jh7r+jrAajSns5weVR2ciKrcVqZWET0D0iNfa+X3pXrRHighaL34PBMKYP4a88lRRJILJassa8M4Z+vgdChJqVfu+DjIcf0XqmjcFpiqaLlzMmZrwj9UbTH/vkqN2m4KpOseVrS8idzZMz5PvPcfI/3p1njO/kbJVWmgYjKSvmxdaUvu47Gxhv5GLTEx7V/Ti3ZYyxGjQxM5KmFkz6XBmzkQJVsTcFvR49Te45187omquK+Ma70DJS21qlof+R5ORIHHwcBRueOdPmGo7FvhAlRb19mSCXkhYJqi5Wmna+pPLavxExTISTOWuyXnnRTnDdUZWfD1ZEpEPoslVWjHQMpztohtX7DMk6Pyzq2A2evIOxni4G0CnkbZtRMXKG/qkP+KpKk6cjx/gihbRkv2L46oULLgzWbp/SrgGu5BWbyrI2XzgCLk6Ipb8u5NhTKp9yehgCLnKEVl4r8ig2T0RsraAde8RjxPqwzr3Pg9b2C2qwFNUM618ty+qIntph0hSxvHc3TkiL6DaAQZz0++58P6qDz+G1RluWq9uYWhND4v+PnpjoIY7yGKjE7fs6Ol64yfU8Xa8R5ynv6XWk+rsZLzeyFn39ztLEcvksaiMf6ZbJujjPCVgBeQEyLLlBwdBRJ+poHBv2TNPQ3RF2bvQmqYZ46571FVyr40uC9QG65nDhSUe4mac2oc5PS9lJJkRXfQGByBAlZDPNsoEeYypDddh5xfT6MqvDbrTLm1Zz/knFg/2TdvfNdu1ByIfekkQcDctU4W69k+8blH7n3phwKD5xYta2fcUKP3DWhe7Z/N1xfFc/QssrXylGmdOlDQirFJ37PrqFWVfxvv8X4kySV1/n58FND+jjpBxZbGL5lXJ0R60FckAXEUDH6YLua8jWs7D9mXNwLL1zk+KwqCNQEnFyzrjIj27FgSf0vunH2p9WadFSVgDay3XhS9IXqve4kqLqQnzZPI/Bh1Khe60pa8e4vFfbsaVUVdR432+ySa945rk35DTVedK75rsxbO60lzW3t1YJ6ix6qdxnuM5Pd88GZiatW0TcB+w/F/R0WJvechO+ArYIP0PlNC32dX2QoXoNq6xpabJN9D2cv9Y19+wii9Qkqu3B4Zz0/EBPcsykaZKDm+EnJUnJyOR2feULBko4K+O1vg10YZpNni8hx1AjfxeSmUKTQQZW4MszllRzw38XM8asZ9lh3aK37egZwBo6V/E7/PQHNu14a+K4n8q8Z4fwN8WNQz2BW3ZIzvQTR4U6b7k/NSB0pWUdbpnEO5azoE0d1k9EUtPt/xDl1IB2b6ooBYE0GvEfN+Swb/gijwsUkJxjGbH8+MtXaROscmQNQ+8yJe416o6eYnKAi4cPI3pV+vUM+I64ElipalAdd6R8wN88bnhWNd2yxZRzrMyEfVDU3IMV6Pw/pKag3Yl0v2b4yqjS9t4Fhl8+nUIc9uNKdKXYmgVInPWSPa71Cyx5aUiE6lzvVNGvPOQ/H78SH7/yXXnukYpdeth+O6T0XBmfy6uBgKNmQOsAEoeNMEnNGO3z8eyoj+JptfEUXa80RSWmeYN1u4tm6IgurtuJ6Jk2MZbVdv5EC/jiqDti1jfFM8kyvXOdY31uaHUMby9bG+jdZIGQscm8xfcDRy2B4WY7IDct5+g2y4dVv4+0VR8GG7Fo5n8+L2sW2AdKBxaW5vXYr00WVzf78HraRc6ywbMCWqOH0zrvlcYNY6561OTT9vmPM1eSZWR4kKTYgO7wfqVDEiffb6OKeJxP9Spg0li3yDkvPya9lYiOatqaVnvattSH+5E5g0Po+KdLTrURDgS2CrdvquPsg+uiI+1+3VhOy+WSgpxWYrr9Wo2X6ZXbsNzf2Y6dy3eKw/22b3Yhj/f3Ka09COhfxzGf3/MyQBU5QE0mX00bJshQtQbV1rQ071O4CFcvuNJPLbWTaGzHpfF2VyZo0ll0e0DFeHctHpOR2LnmipKdz9UUbpHUhJXwUZOCdQazzYLy8zytD5ggKbVKMsrrpVSojqKmuOlymqpXpeUDbvWyQO7Wprl3HNnu2lsuejNe8boolookR9VNp4/YcCPw3H+R/We4faUZ6pUEXZczQvz+9GEsBBBuKOKEt/2o6SZzhlnxglSOzPkJm6y1HjxR+IqvjWiWOzAicVLX8br7nLGwHxTH6EAidZYP9h5MQaJz5PgBz5HVJxhJJvMkqxgcCBueOzIBrVrxCF1QOoGuS3+L1fo58JakHwKZJjA6hRfear9nZATutSZueGjJkRvg7SO29Bjo0DSAzorrihgP0XqMqrZ+7Y+DR3RowXetXB7SxDb6Tnv4Kyvgch2qpO59xJnqVewHrIgb1NvB9XoqSENGFoTuTwOrVo2TvjhvoDnUI4CpEjbabkeLe4B1vGOP+CghjTdeV1Lpmvx0W61yEE9TJqhv056rP6K6oMuYI6Nki8m/WqhdMeIk0owP1RzPMPxfp0JEpM2wmtq5eT9K3tahvNfRj/h5IxPox5bT8KpuFL7llvZPPfhmz+ZWKNzpzusyHdJ6PIGyfu876of2zpgsuxVv1MokPln1tE1Xdh0bJ24BhkfrFxUWXhEP1xgbERndlj8d6+Qht8OMDFNGc3OQv4JndO75ifV4s59x5k241X9FgN57X+s6an+1CS1w1IV3wOWLrO366NKsCGScWH7IGfUEJUXo+eOubRV6kleqVVPp1OVyrzVrgA1db5t2TiWCsmvhWSY9OgUvD3UebRIkXL28ZrzC+yhyED7ifULLKJyA7oKpMUBRkOyfN0ZShscyTHTkGOi9uRwv8rcDa5qhpqwZCG3wvkZDgt3oXPEbXNgnFsPeTkWqDo+9uK61iQnLOu2tptbHcNheqjUFTrGk3JuzBVPOttashYlg1lPDYBa8TnFt9PFFx4Hdipg2Xag5qRsB51KOgQ7c7bwCVFj2Ei04woK23j3P6NkbPzm5gbj4zfPyGXWZlf16qt+A1lBH8ObB6f10VVLYvTvBLy9VTX6gA5RkXB5UtC1/kke2/j+FjxvpyCKlduRg7IiTpKpjoy1guCpw6qs1FmcRrISSsYx6Zg+tfhuNYNkfPnU3I9brriBmwX93SRZF8P6iS4AIvE+9Bu9zJZexdAwfEsuJE54TuVYz15V05HjtFZ4/N/4treQk7zNWJ7HOmwnS7Zrugt/2xQqwS7D+l7YyfHeiL97qh4v78hqBC78oaCWG9Sq2KbJNa5LePzqsjG+xS4P/e3remXu0s8v4OQ43YDlPB3PvJHvBvfnyW2rFDv3nWVjSED32uj3nNZT5Eti7p2avb6f1GlbkpZtxdKxniYWiDvZlSRU6pkxxaubRQUKPyK5tXt2foyNjX9qUv4jloYh14oqedPZGtNG/ubrekoaH0SbaBkR/SGg2N9OxdVhyxErT/z5kiffRlV62bVXO8CBxU9RsN5rdl63g84AwU403GcECX7PE6Njm6WuA+TIR/VB/l5oYXvmhRV0hwVn8cg+rFlsgBzowDYN6hastWUa9U2HPe9aAGqretsMdG+Qa2ny/8hHs9fUSbLFySN4zrjRvPsvvHjupqAd4qWrStsiSIzZ4zrVrkxPyf234XKbO8KJe4fR0ZrFqEGXcvsoYj9Gu/FUbGg/Sd/vWXdyi5fZ91CkV8cBSAHo4yXf9Ny+faaoVh2qmbHda5jOpRReh/NS62z9/6fXlvIWf0tsGgD5No/5pVfkWNuHVTpN3X8/hoy8BtWQdAKmScJg+PEZN/GMce8Q3Nn50pxfUc1UsZqa9N97YMoi65HFQQfIWdGVlU6OqpY+zA1nNpZhtT464ccPA/GM/QYMFtyfJT4WXfuatCYpUHwbVDAaZaYWzfPr2PkGtGWeUvmxm4oK/0HYP/0WoqWsYOue6J4xj8il2kfY5FWZB8fa0WHVB+FLvciqiabsbONO80rRq9EwZl+yfGFqfXyyLbHSYK01TZc4zwJCnylNI3bImfll8BVwMo0t21GRYlSnSKI3A5jtSLyB2RVExfE54wueAKUvHAgdXqUteL/j4KSba6JdeB2pHOPGsfnQVSLm6Kqy06VZT+Ma8+CIP1onvRoNK+mGwtVH32IdN+VCpA1W9+mi3lnW5T4mO0/JvZfj1g0zkY67uf5daGsG6royKoeNqC5w3v5WLv2KlrODh6D8ZFT/3FqlJBpi4EeufPbtL4iW+cmFLB9J+aVJhSk+TPG+jEUwF2HkjAntOE6s7Xmmri+p1Ay+azJOd0RE9BuyH/wF1rn30e243CtNcl3PhTz6aJElWTs74OCR5chv9yvNMB+H5m2wgWotq6zoYzlv1EpXVZa/yKwahzPFq7Zipa1lddT12FNzuBHivbM8XunyJRo64LYQPmeRVkA0yX7JkaZGocSHPQoYyBzuF5VtNwhU/d0fOO5/18skgOBg0iy+Vt6zqqt62/IqNoYOWkHI4fK7Lnnp28omB/QBShxEM1YE3KALZ3sT695duBR4JEGyjUfSjLInFY/xz1pQvzpixY9djl5DfW0+Q0ZKWfG+voTuUo+xGf+OXBs0XJXWzOnynTUyWRHjotfUTD3W8JpFceWBj6mA2mLcvJlvUOmQU6TjDbzApoHXgtLlmDIIPhjyEH6IDDmUP6u1HpQHXl7xrgPAnYpWp4OvE6Lbdd41t5ElTeT1zl3cyKTtoNkyagyN0WOn0spUfC+teMZP/+FOOhPjs+9aR6gnQc5vf5FnYrTamv183JZ6A+b5I71oUY7+QGqUpy/aJkLGKMs0J8FaMZE1QgXJOfMghy8C43gdw1AOvZLsTZcTSfxQbTDOF+I/DC70LxvVffkHhyB7O39i5AxkSnrM5faBGMhffaYbD5CQfo1UPLCq7SxWX0B17ciSi79E9FxnYYCUF8ALxctXwddc77icBQUKD0t1tIfkd/wn6Q92kGPRMkJW6JAxlfIL/k4SiSvS7mWl7XsW4xVb2QjZPZq1lsm33N7NNRbaUcUcLmJFvqBtfJ790D25HcoEDc7zRMUJkCV4c+NjOtbh973ogWotq6zoRK6F2Li+D0W1MWT4+uhLKMOayw9gvJnhk136hiHdc7/JxukM2ydRVaUYflQLLR3Eko7cmi/hMo+88rAI7FA9y/L4kvzwF43lO3wcSibN9CB1DbV1nm2UIImQcG8z5GRckSmdKHy7u+BvYuWtZ2udyzEWZ4pmv9FzqLuiKN6bmTAf0GO9rBB8i2AjMRjUXXc8mWZU+rI2hs1Mv0aGYO3E43hae6MWyLW3p2Llrna/rkn41ALCC7EkJmGRyAqzR9RD5O1kfPlXUQF1W787YnuMzowfrL/rXgHMgdPd2BeFET+AQUMdyl6LBN5syB4Zsg+AsxetFytkLs1dD+ZY6M/ytRvItGvu+qGHHQfoSzRu1EPhtlQkO60mPvuaJAsu6DEm+tac8/KtKFATEaDdi3Nqzw6RbJZmbfk/TwaVS7slR7Ljfe0iKbnJ5SwsxcwTdHX0MHjkyUC7IsyvafKHb8h1raJQq/ZK9a/Gdvhuw0l/R2MdOyfEW3sJEWPSweP+drIcfoNcCs5+t94LvdA9HH/VLkXIGcf1Lu2CXgaBeLHAM5DAfvJ83KhSo13kB5VSv08e/aS38dC+vpnoT/9CpxKjra4q21Ivx03+TwWSma9Oe75G8CKI/D/R0PVomeQ6Hvxzh8Z//9zVJUyb3K80697iFrzepQAsEOsPU0oMLMadRI92+O64707GelDb6Ckmilzz/sERY9PV9sKF6DaOv+We0lnQZy9B6YKEQroXA68VrS8Q7mOTOk+BSnTsxQt0whcy0zACumkmShlB1JiYz8U7OlRc7N3kDPyJpQltVZyXmYE9EHOymcpYQYkzYM3E6Lsmh9Q1s1pjAT89NU27A05ROcIQ+V31ENlp1A0Pypavg643tWo9QrIFPcv4/cXgA2KlrGzbCibdHKaZztlzT+zINn3hKOfEhu5I8sG7Jk8+3+i4OW0ufViOUQlmNIWXUgHZa8hZ8nViKrxQOQ0WyTW5DQI2AcFM7PgwcfAaEWPachm1CpwP0NBryNIMo3LtiW6zGG0IsiEHPD3d6RMRW+5522m0Mt/yb0Lf6Bkh8kbKNeFwN1Fj08b5B4NNXXPxu5iooouOadTUAaWbaNmW02ePJMDYl+25o4a+t0SwPSx71+IrmYQcGnR19GIcUJVkJeR630GbIECsC+jwOIPwJlxrF0CCQypY78DbAL0L3psOnjM90HO3E/i2pePY3PF/biraDlDnpVQsu8glLg5ENg2OZ7ptD1iHn6TAun2qfmM6lZv5O9D8vuoyME9dkfIVaYNWDLWm7MQndYoybEpUFXIs3HOo7RBj0QJdllgcon03sTv86De2l+h4M3J+fmnM27JurM+0o0Ojc/7I3/Zj8jHtGDu79ptnUe9Z2+j1rNtFboQ1WTZtuyGV6gwXDAz8+ThMbNe7j6whXNHQUbzlsBG7n6zmXV398ENErfVMLNRUXXHc8DR7v5dwSINN8xscpRJ9wuwhbu/nxwbF2Wffg9s4+4vl/he9AZmRtlBqyFHzEHAGe7+Q3LenIgW5TJ338fMurl7UxEytwQzM7TANsXnBdDCuhzwgLsvWaR8FcqDmC8XB3ZGpeQ9gFXc/ZZCBWsn5OcbM9sIZWKNiQzMB4GL3f2XgkTM5Gq2xnUW1Fmbd0MBgsPc/Swz6+Hug4qTsAKAmWWVAr8huowNkTF/HHr+v07OnQn1t/nY3d/tQJmWQw610VAW7s3Aju7+VRzvDjRlz5eZjYcaRo/i7id3lFxtQcg6K7A90iE+Q1mXN7r7T0XKlsHMZgV+dvcPzWwRNPdtDFxeT4cxswmAr8qm3zQKZjYANaAGOV1fcfdXGyxDd+RYKnR9Gh6ka4KZTY/mnSVQ5fr5wE3u/mn+3ArDBzM7HjkmN0mfSzPrgyprVold36IKy73c/Scz2xt40d3vbqzEjUFmk8X8dRFwn7sfV0dXWR/1bzREl3Wyu//V3jZdTsdeEr0HS7r79+31HUWhpffXzCZGPdGWi11/o6rNHigJ5LUy+ALMbDS0Zu+GdJ7/IkrQF939rzhnNpTIeae7b1eQqP/AzB5DfqNz3P3boZzX3d0Hm1kPVEH2csOELBBmdgby/30JnAvckl67mc2O9N9+7r7lcP7vTREzwrnufkCyv5nPJfatgnoezome+/Xd/c42XlbhyK3rK6CA7GnufmS876ejQOj7aJ2/wd3f6iBZVkH69WSIZnzHTKeo0H6ogjYVRghmtjTKuJwYZT2clA90mNleiJv6SnffrfFSDhvZ5Gdmk6Jm9/e5+wllDAAMC2Z2J8q8Prqeozcm91OAN93938n+UhprYaj/H3JmrIEU7KOQ0jYaKjfeFBjL3QeV+Z7lZTOzLVAVxb1lUJgrlAdmNiawEcpa2bdoeUYUdQz0f4IH2e85JbSU81FnQTw/BwDrokzKTQsWqUIOZrYSCpLcg+g/VwfWQtmmRwK3ufsfBcj1MdLpvkH60I3u/kLunJ6ot1ypHV1lddCFI/dQYCukw2yG7vuO7v5FnfN7UHtGlnf3uxoobuGo1oMRQ531dzWUcTwxoia6ANk9PxcjYedGOAnPQZVy8yb7Z0OUfmuiqpp7UGBnKWQv7954aRuPSCY8CfU7uN3dD0+O/WP7xDxn7v53fO4we87MxkCVNtOUwfk/IsjpzhOg5+2P2B539w/i2DyINm0sFPi+zd3vLJvdbGaTICq9rVFF/nmIBuqr2L8rMI67/1aYkED4jC5CtMqvoQTlO939z6H8zYqIDnDPsiW7tCfSZyrG6UzkL3wW3c973P2jOD4aMDgLzLXy/xuqnLkJONjdv673HOdszb7omVoXUUl/TSdG6OGDkC/sQHRtO7v7JXF8YZSkMQti71g3r8vn/l+b9azQtfcE1nT3WdvyPyoMHVXQpsJwI3GwbYb4e3ujyWAaVM56DMo4+C2y0v4vznnG3X8pm3KQIZSZy1BZ4T3uvkuxEg0/4hoeRA3HLopAVC+0GKbZ7XMjpeFkVDK9DLo/5zZe6tbBzCZEzpcdEK/+TcD96HnbszNlkVcBmgqtQSil3TvDM90WxPUR81TllGtHxLx/JKL6PN/dv6jmnXIg52DZBGWVnoqoEFdAAYZ5UAXpUcDzHT0HJFmg3RCVxY+Ilmp5FOg4D/UOyZw/CyFn5P5DMwLLgrI56MI5uTCSaV3AgePcff84nneyj4ocQjsCc48sWbopqjWi9UgS0bojB+0A4N06Dq0DkRN0FJTMtVs1xm2DmZ2Ogq8zuPtHkXB2GZpDDwHOcvdvYi66Htkxk3jCHNBVYWbLo7EYgOhA10d29m9xvBvySQ1u5HveVXTsZP3eCekPUyBfBohu7nLgFHf/PT0/+ftSzq1mNj9a9xZHVG4Po95ih7v7sQWK9g/MbCIUiN2Rmm/iaOB/SdAim4/HB45HFcrjufuvhQjdIISeQxI0WRL1npkSMcJcCzyST/Zu5f/eErGvbObu9w7j3O7AZB7MM2bW30tScd0aJM9Pf9Ruohvwjrv/nguOHYtojvdGFftZ8HsHYAd3n76V37cPet+eGJq/NpHLUAXyb2Y2ytCClhXajipoU2G4kLygoyK6iTuBA9z9AzM7E5UeOqq62dej0qOsCkEKE2XVKYjnFZQBeZMPpdy1bDCz+RAX7LbuflHu2Biogev8wIKIt/4HVCLdDZjD3V9qpLytQc7B1R2YGik8m8Xvb7d2IWokUod00bJUqNBoWI0SY1bkNHqoehcaj7ImSYzMyK1powAnovVsQ3e/1symQhUV2wJjI/72k7KASQfJ1NPd/zazcxAF6cuxf3mUGDETtYz8r1GgaX53n7CjZGpvlNFBFxnFLyEH21iIF/wgd38qd94YSFfzLDu1qyE/V1VzV9uQOHAnRJmvGyAaxl+A49394tz5YwOXAre6+5kNF7iLwMzmQpU0nyCH11zAfMh5tmnu3DMRVdVS3oGUl0WhTtC5NwokrIOc239RS1T4yGuVNqX3FZQNia49HfAiChpcgfpEro6SAqZGPegOdfdPOtvcambrocrx6YFP3H2ygkVqhsQ3sQpqyj42Sn453d0/TM7bCOlze7r7iY2XtGORPItjA98lem5PYFDy+Wr0bP4InO0JtdlwfFdWWbKAu3/c0twRAeG+6J241N2vauPlFYbE93ovojZ9DFUt/g/1gP0G9XaeCK35fYFd0rWltXOrqSrqZaAn6sF8+rBsj/A9noD6kF3Rhkus0ApUQZsKw4Vk4jgAcVBu6u5PmFk/VKZ4KsrqOBtV1zwE7OHuzxcl8/AgjJxl0aQ3OWrW+V/gtc4QOY7J9nlUTnwoMvKnBZYGpgLGQFy2LyEjbknEefm8u39ehMxtQQQNZ0fG6Hnu/oIVVGWTc8D1AjLHUN2MpgoVuiKStaEf4ibOOPI/QnzuR3kBVE8VKhSNxJBtMbvPzE5FTryt3f0BE43DjMjhshPSo9rdyI9M1o9clVgroj426wLX5hzouxANtoGfqfXauq+9ZRqZEPPl5ijRaSaU+DQ54iA/IhxsoyN9bjtgDB8OCpGyo54jwcxGrdaKEYeZ3YEq9m5DNsHyKGnrJWAnd3+0QPG6JMxsXmQzTo6YJ45Gla4/WY2lYgzUb2AWYL6u9KzXSbLrg/p2Zft6o54Su6Pku2dRsuT93smpioqGmV0EzI3oid5I9k+CKnbXB3Z191OKkXDEEGvlLsCDZZ27wjcxG6K23hD4DjgWreeTxc8J3H3qwoTsYJgoIc9H/Rkf9Ob9GXu7+lQtiipuPkatEy5pw/ccgZ6HcYY1h8Zc9Cmq0OqUiQlmNiXwJDAOCs5eBfwLPVdjI938UWQ3TITWoV1QgJzWBmljjp4bUTVvhpK7jwGu8Ob9pDO7ZjRUdb8fWs+eHbErrdASqqBNheFGZIaehcrpd3D378zsXGAxYBF3/9zM9kOGaB9UifPf4iQePoTjfVJUabMNopc5HbgO+LDsDnhTQ7BjEFf1qCgr9g5kqL2NAlAfmyjSbgPmcfdPChJ3hGBmfb34huVZVuM6SFEbGykHt6MMu0HpeQWKWqFCh8PMtkFVfBchh9F2wLLu/kSRclWoUASSYOb4aE14CxlWg1FW9g+ILqY3Wqd7AWu4+8fx92OiPgkPdIBsYwL/AbYADkPNYm9BOtt3qfzxex9UYdMXVc7d3t4yjcwwUYnMh3oObIS4yk9Bz8b2iN7mkMIE7ECY2XLAeigZ5y2kr17jHdQ4t6sicaQsj6hntveoujezZ5Hd1gvRWV+MGBG+LErerojI7J4YZZZ/HvvSvi1LoHtztLsfV5ykHYNYJ3ZElFZjoXnsKpQI8EmcMwBljO+NnNy3owrP+4uQubMjAvuXARO6+3yxrwfQ5DXqpDuAOYBpi7abuzpCt1oAVYIsDzyNKp82Bf7t7ncWKF6HIFl75kUVdOMCN6LgwXOeUMFFstAhwMptTUIx9We+BSU6/TfmXW+h2mYeVCV+rruf1pbvKxpRvbQaSsJeEXgO6exfoDV9fvTMOaryvM7dzxmB7xsDtbfIbPpnEFXhfek9M7OlEP3i7V71Tu1QVEGbCsONiFjvh7Kp9wxnxCsoUHC6u/8ZDux9gI29hJRbMIQzYmxgQsT5nFVIdEP8pLujapQ3kZJd6tLKKEOdBmXC7gWM7u6r5s7pjrJADgTWcvf/NVzQoaCzlG4nSspkKCD2BfA+MANaRF9HdBQ3x/mG5t3SX1uFCm2BmS2OqFbGiV03ojLtL+J4RX9RYaSDmd0IrIwMqk8Qvez8iIbgG9Sf7UeUEPMQokr7rINl6on62W2CjMHBwJFZYCD0BJDjJ6W66enBlV2h/RHG8kIocLMiui/3ufvKhQrWzkgqD1ZB1fl/Aveia58OOBg4titVFjUKZnYNoj3ey93fN9ELXQQsharBrwTGi9M3cvfLChF0JEFiKyyIeghN6l2oWXNyfUug61scZdH/iDLB+8fnU5Cf4O8IKoyHMrqPR2vPQUXI3xVg6qm0EZo/X02CNb3cfaCZHYUy5xfyklLydTX7IKqclkZJzPMDD7j7ksVK1b4ws5lQNd0nyb6eKPH5IOSLOgcFql+OJNdtUM/Nf7n762383vFRAhTIj/VC7O+G9GyLOakXSkw6GlGpvdaW7ysLzGx6FETZCvn6LkOUuh/mzsuqmkbonTKzidEzvAMKsF+D+i8+b2bjorl7LdSjqdP0CeqM6Fa0ABU6H9x9sLsfjgI3IKVrIPBTBGx6AaOjSbOU/WAi68nNbCwzOxRxQj4LfG5m55nZvxDF1VMoU2IdoB81I6e0cPe/3f11Fyf9ZcDSpn49KSZCDY9/KTpgE4GMZugsQY1Ezh1R1sNq7r44sAjK6pgIuNDMrjSz2VzoFNdWoUJb4O4PuPtEiC6zB1L2djOz+bN5NzvXzHqZ2ZSJc7hChS6HMGC/RVW7r6KMtYtQJdoNwIfImXIwqoz9G/FJd5Q8k5koqP5299uQLvdryHiQmT1pZvOErjcY6B5/N52ZzVIFbDoW7v6Du9+KqmvmQBnpWxYrVfvDa3S2J6NA5QruviXK5vwj9g00s+5mVnrdu0hYIH4fE1U4DPRovIyymi8DnnX3h1Bl3YvAecCDjZZ3JISZ2cKIKnZC9G53CYRTsCmeu+OAMZHeN527z45YOPZEa9sJwA1mNq67D4rEhFMRpc8h2f9r/FV0XoSTGhTw7oOSMcfJjkXAZjTkkxmM9JDCkN7fCNz9kyASfplO75vMrjECGRejaoUDUVCt0yO7RxGkPQ+4w0RfB/zjhzoDUUBeDuyBEvguMrPbUADlgbYGbOI7vkR9jiYE7jOznc2sj7s35XwtiyGK4ds6c8AmeabeBE5CidcnogDOG2Z2hIkJKcPfcf4IBUFdVOeXxPcdCiwMPGhmhwNrooDNIVXApuNRVdpUaDOs1rh2IlRR8CSidVgG2B81i1uhSBlbQhZ5NrNrkUF8P6qQGBsFM3qgqprjs/OBsd39m/Tvi5G+9Qi570d0b6cgB9HEiOdyVWBVL7hMN7kXK6IeO5OhktdHgI/dfWCR8g0NSXbZNsD/ufvGueMLIuNsCcQreguwK0lDvgoVuhJCme+BFPm3gJnRuvB27LvVg/LGxGt8AGrK+UIR8lao0CiYaCOOQHzRn6H34QIPqhIzmxE1F/2yo4xLU7PsB5DxdXo4dCZCBtlLqLp4c6QnXIo48L839dg5Po71rNavCu0BM1sJVZdt7e63maiV3ka66t7u/lskUa0P7OPuPxYnbTlhZv3c/ef4PdNJ/w8Y1dUfK6Pj2hq4Maqb9gAWBTZ3968KE34kgqlZ816oWXOXoQFLnrkrkL63h7vfYznGhFh7tkUJCrchJo4f6v/XCnmkfod4p39196dz52yDeqh8h3SNx1CQZg1U9XClu++cvzeNRPK8rIQcvmOjpMcHgUeypJAiZewIZJUPRcsxokh8Nt1RwvP3qFfM/S35xswsq5xdEPVEzPqqfT+isqCA2PGoHcATKDnhHvRczYJYf/5CFWY/jsj3lQG5eaAPCqJsBKyOkiX3c/fLO+i7R0eJRJui6vz+yNc7WUd8X4XmqII2FYYJq/XsGIAaXY1XR1FYD0V+M0qcd4AlXU1US9XLI1EY/gXcB+zo7ufGsX7AtCiosR5SfvYvk/ytRbKw/htR182AshdHQxlP53rBpejJs7UACi79hahjZkDP0FnAraiXULZIlS5gZmYbIUNkKcTf3Mubc36uhSgD3nP3NYqRskKFxiKZaxdBc+k8yDC7AM1BuwAzufvkhQlZoUIHI68Dmdn6iMt/WsR1fhFwtdeoWTtsjTOzSVF/vvvcfb/Q6/7ypJFrOITWQTpQN5TN1w1VlO7p7md1hGwVRj6YetlcAyzl7k+Z2fEoQLNYZJSSZHSu7FWPm2Yws3HQ+F0FXOJ1GjKb+PwfBjZw9xuiaulAYEF3n6OhAo/kKKP9MiKw5rRvj6KKwMs8oeXJORn7I1/BJsBKEajtUmPSEUjGsi9Kit0D9QHa2RNapDi+EnJk/x+yqZtQtewjqJ/K4KICIonNPzuqOP4BVRrPjhJZ7kTPz5PJ35QyeFMnKFlKOdsbyTt/AlqXt86Sf5NjfYFJEAvPb16jxx4f0aD+PDxjlZ9LIljT3Ws9gydHVXwroqTBP1H/NtD6eJq7Pz7iV19OmNmEKGF+c9TX5gVgM++g9hSmlhILoUSQE9z9vo74ngrNUQVtKgwVyQTcDxn6c6KmqF+i8vqrXNU2oyOH3FSIL/khd3+3zIuYiRZtS2A5d38pp1hOCZwLzATM7+4fFSjqCMPMJkBK8pgoqHABCoSUgubEzB5Ai/uBKDt/OkTZsjIyBE4DHvaodCoaVuNiXwQ5tsZF1TQHufvJcU53pFQMjM9jgKhPyhbIrFChETCzzVD23/jA74iq4d/u/lihglWo0ABY82bUvVDgZhtkXN4PnO/udzdIlsz4fRi9i8cAL2aZiOFcWxY50BdHesOd7r5uI+SrMHLAzGZDlV+boCSqH5Hud3o4fidAAf8p3H2houQsK0y9a9ZAevNraA65M3fO2MDdyIl2KrJr1gC2dffzGitxha4IM3sa+AVY3d1/qmfj2JA9QP/r7jsUIW9nQ7Jen4kq5G5w9wNy50zr7m/H71MD0yPH6ihojn3G3b8sg/1pZreHXHu7+3NmNi2qBFoO9T66HlUFvVegmEOgXoDRkkrH+Fxav1d7IQL/TwIXIqf978mxeZHPZh6UnPcs8jnd6jVK1OH9vjGAvu7+sZmNln5f7ry50TPfC/kiH+viwZpmz6OZzYD8ZnsDm7r7TR353cD4WUCuQsejCtpUGCoSReFSZMBfhQI2CyLO2udRKV7po6x1JretUPPTaSPA1B3RP2bN+xZHRuRS3klL2WNSrdv4vujspuTZGgst6E+4+zG5c/4NHIWCONfGeQ+VRO5RUYZQT1SSOhnq5fQIsJu7Px/n9wRxvBYjcYUKHYtcwHtWxLE7GCnsl6WKuonDentUtfmouz/QeIkrVCgOueDN5Ig2YjXksL4euNQbQBcY+sHuwG4oGedc4GrgTXf/M86ZEDl7/0Q0CCNEZ1GhQh5mdhlyNHyI1o05Ez18A9TEeGt3v6wwIUuIsFkuRxRDn6AM40HAzcB5rr6WGWXp8ojXfx5ET3OVu+9dhNwVuhbMbDWU1PkQ6mlzb5IBX7cawczeRTbfRkXbomVHMmYLoeDL3ogp4zer0dRvguzjE4BTvXlT+FKMb3Ido6BA/A+oF0bql1kSBW9mRD23rkfXWqokR1OF6IaoMfsnqEXAFe7+XBwvxZh3FCI4chuiQrws2b8KqsyeBLgL9UpcE93Lf3sbqTjN7B5En/8w8rd8Fv//L9SnbWCWTNvWa+rMyNngPVE/sVcLFqtCO6MK2lQYJiLT7RHEw3tS7JsI8SjuBMyHyg/3L1tWBJD1TXjf3T/O7Z8dZQrcizLOPov9WRXFisgg2tzdr22o0O2MRFkqRaAm/YwyLFdHTeLOzp8XGclboQzBk919t4YLXgdmth+wMXp2HojskrUQrcz4KANl78rJVaGrw2qUBzugLOnxUVPzQcCnwHGdfQ6tUKE9EY5UEuf0Ioj2ZEngDm9gP0ATxdL+wHbAeyhL8i7gg67seKhQLJIEmGlQz8V/ofXiAOADpEutjqrClyhO0vIiHKAno2bMd6OEiSWAN5H9cnHmKDOzSRDv/+/A117ifpEVOg/CSXgyqhr9FvVCu9Ld/5eckzXR9ngO70FO3727elVCe8HMHkHv7pYu6vnMrh8VeCNOG4B62ByLggil6xlkortcBCVt7R/7eqXzkZltia7hSnffrhhJmyPxDa0KnIkoY59GFU0Tod4u5wMneRdvyh6VXG8Duyd+wVXQPNAD2AHpsQOTBOn93P0/bfiuiVFvpoHA/4B+iNVnKhTAGTWOf4qCZ0+gvsGvj8AldkoU7eOr0LGogjYVhonIjL4EuM7db0j2d0OT5iqI13BKlA333yLkrIdYWF5HFTPrpgtpZKn9BwWeHgD+ixaZP81sCpSBuh4wYewr1WSYKGy9gH7u/m3RMg0vTNz+l8bH14D13P2V5HgavBkP+CnuRaF8vPH7auj5WN+jf00YJsugDJyVkYJ9hrsfWrbnp0KF9kAyD40HvA/ciJqcfwbcgUrV/0Bz7MHu/mL8XfU+VBjpYUP2u9keeN3dHyxAlllRZevy6H09HWVDf91oWSp0LQxrvo/AzQ4o6DAl6sPwF3AxCvp/0BBBOxGseX/OS1AS2saI1/8IlO38NBrDq6pq7wrtjZyNNg1wBko8eA1VftzgOXpxM1s2zjvC3S+sdMFhw0QjeQvq83psmoRpZucgP8wKiKp7W9Rf9Ulg7bZWN3QEzGwl4CZUUfklsI4HfVXYzz29RineHxjs7r8WJG5dmNnHaGwPz6oZzGwd1KNzdvRcH1GYgA1A+J2uBBYDLkPJPgcCYwAruvsdybkzoKDKqe5+aBu+qzfSDfYEdnH3q8L/OC3q3zImCvB9Hr93Q1Xrv6Kq3Z/r/d/OirzNUGHkQRW0qTBUmBqonwv8Bpzi7sdGEKcpyRAdBZgFVUOcnWbXFI0IzJwEfO/uh5iaoE3v7g8lxw8D9kET/BtI2VwIGA9lAZ1T5rJLMzsYmBhxWT+VO1YaZdjM9gXedvfrE2VzTLTob47o925DGZfPuPsvyd+WiiPWzC5Cz8coSFH+A82nWUCnPwra7AT0cPfZi5G0QoXGwMxOR7SZm7n7C1GN+QGaf8cCNkOK9M3AXl6S/lQVKpQBZTLEImPySET5eS+wo7t/WqhQFTodEj0vdewOVZeLCvgxgP6ILu3lMul+ZUI6luEYuw142t3XM7M+qGJpE9SE/C7gIu+kVM8VyotwoKb2z7+RHTclSpi8ELjL1c9zdKQTLu3uk8f5pbFTywozmxl4BtgwZ0MboqT7xN1PiXP7Iwf6rsB4ZUvoNLN5gKNRr7zXUADvZq81q+8OdHPRvpXq2TCz5VGwYit3vzqXyDk6qm5cEljGu3AvFQAzWwD1Qpwb0es+j9hQLsut+YujwM7x7n7iCHzffog6by9EmZdR+K6P5pgdUZXNTCiI+YLnKPc7E5J3vBdir5jA3Z8uWq4KxaEK2lQYKkx80rugiPY3wEZJVkQ+Q3Q0d/+9bIssNJv8rkOR+bOB6939tTg+NTJwZkMG4wfAWe5+TVEyDw1Jme4aKKh2OeqjMkQmXRmcQaYmg/9DRvgCuYBMT2ACxOm/O9AXZWhdDLzhJaNwMNEF3gJMjcpy93T30+JYvi/S1MBAV/O80gb+KlQYEZj6Ul0PvIBoMn83sxtRpu/C8fliYF4UYF47zcSqUGFkQDi3vCX9qL11pxH5f5GMsyewprvP2l4yVRi5EPrd/qgJcTO6pPTZzAUgRkHJLqXKsC4jrEZN2h1V2RwNnOPuB8XxGZCjaxnkWFvRqz5yFToAdXwCuwOHA4Yc3ZejRLfrgO2iyqayi1oBM5sDVc3t7+7H5YPfdcb+EGAlYC13f7fhAteBDUkJuy7qfzIeSua6CPVDqttkvgwwsyWAOxHDxrURNAPoHj6Z2ZAdtJu7n1yUnI1C3NMlUGL36+7+Y+zPfFT9EWX2tsDEbal6sVpFaX8UDF4Q2MTdHzezAWi8n0O0gT+2w2UVjmRdHx/NoaugCqK/UELVxZV+NPKhCtpUGCbMbE60+G+EMi/PQDQ3P8TxwoMCLcFyvVwi4r8vMBfwMmpuf0OS4TEh8BVagLMS3dIFoTKYynTvRWW6H4YCMS2qWumBylFLQYlgZsug0ufbzGw+VKFysrt/F8d7I7q9bVDlzReoj83tXrJeSWY2Ixrj9YE5UPPmfTxoACpDpMLIBBOn9hnAF+6+fziKnkc9Mq6OoM2RqA/a4e5+T4HiVqjQochlGfZEjqrBmTOi0TqTme2D6CmeGEaVQ5q9O5qr0fEoWUZjhQrDCzPbGlH6vIgovG7w6C/Zkm5tZqujfjZHuPtLDRS39DCzcVGG+l+IoucrYBR3/yOOb4p6Up0KHOnuv8X+FYBN3X31QgSvMNIgtX/MrB/qc7EJoi8y4DN3n7cwATshwjl9P0oUXMSjUj0X7M7W7wmQc3tcd1+0IJFbDTM7AvllfkFrxPXu/nDBMvWrF2AwsylRNceLwAZZFVMy9lMin8yN7r5HI2VuNOrpsXWSMTZHQYeT3f3YdvjOfsANyO+yAkpG2A0lIzwc53QZ/4uZ3YYqmW5EwanVgKWBV4FDPGlZUaHrowraVGgVouxzAWBtYF3Uq+MQdz+jUMHaiDBs9kS0PQ8B1wC3ZAGOMgeiMpjZmsg428Td74p9m6Io/HhIOX4O9fIpW9DjfPQcPQ5c4u6XJsf6AHOi0u6VgRPcfc9CBM0hpyB3B+ZDjXI3BkZDvKpHe/S4qVBhZEKSXbU6mpvWdvdHI6izK6q0WadyAlfoykiy5NZHa8NYyLl6i7ufnT+vg2WZFCWo9EQVxqf7MPqDRFLFCcCZ7n5FR8pXoevD1MfgRESXdA/KqL7To8dkmoFtZlOhSusZ3X2cYiQuL8zsMWSLvQVMjpyH71LrIdeEsnL/Dzi0SpCoUAQi8N89Cd7MinqkLQTM5+7PdgY7u0wws+3QGF6LKupeSpNDXHRi3ZHdfDnyDVxdhnGOef3/EO3le5nPIjk+EaLNWwP131qv8VI2k+dFNK/uniRjZoGZA1HfzstR5dPHyd+ti6i61nX3GxsvefvDzMbKkmuH429GBXZGiXv/c/dV20GOLAl7SqRD9AFmRH6XEzzpWd2ZkVznEojVZQd3vzCOPYbYaH5F79NVqMfVi0XJW6FxqII2FVpElOWNhjJEs0VrPGAx5IhYCvgIZW89UpigbYSZjYbKNjcD/gRuBy73XF+YssLM1kYL1yrufndkNO6HFI3tUAbCCcAa7n5zYYIGrDn36xjAlsB6qHHck8hBlGVKdIv9ywGPuPtH+XLwsiBKdv8FbIiyID4E/uPu5xcpV4UKjUbirJ4HvdOnuvtuJh7ok4En3X3jQoWsUKEDkRhc0wGvAO8Db6Mq5XGRc/XIzKAP55Z11NoWFaxzA2shXecHxEN+RVYtnZM704v2I5xrHSFXha6PvM5mZnsDhwAOXIF47h9JEmF6It31JETrc13DhS4xzGxiFPSaHs0t5wIzA2PHz0lQMGdGRIV2JaKl+YUOnGMqVGgJNiQl1uzu/mJZ7bkyI8bybGAL4JH4/cnMPxPnrID62Qx0938VImhNliyJaxXgKDRvfY+qhZ5DFGL/y/3NYsDn7v5Wo+VNZOiP+hyvj4JMx6CezlnVYjdEp78bWssuQHrddMC/gffdfeECRO8QmNn3wN7AeUmQcFi96aZGFPfPAKe5+/vtLNOSqCprLNQfq9DKrI6AiVJ8XGBnd3/b1A7hSsTy8j0KGk4fp+/g7mcWI2mFRqEK2lT4B4nDbWpge2BrlLX1GzIUDkiCN9OgiWMf1KS2dCV6OYqS0VEQoEc+y9TUb+UQdD0foiyWK1JFqIyIe3AnyuD9AgUMLgaOcfc3zWx6FIg63d1PKk7SGiL7YlPURG6QiUZpBxRgakLynuHBwVsGxT7JrpkNWB6YFVHNvIgynX6N8yZGDQh3AiZ197ELErlChQ5F8k50Qw0SJ0Gl203xXvdBmdVrAn8jI+1LYB7vIpzDFSoMDWZ2CaL73NbdX47swFXROzEt8DCimX25QfKMgTLztkGOhWeAI4D70spQM1sKGYO3u/umjZCtQtdGji5pAArgb4QcXRcC17r7K2Y2E+p38W3RDscyIvTneZEeuiXwNbJdnozEplmAWYDRURX4XVXgq0IjkKdFqnO8y1AWFYEkqaIXsjF3oZbw+AbwDjAP0jFeQcm0bxRVZZOzET4DXkdz1UfINlgtTr0c2ClNICkDInllVuSv2Aj4GPnAro3jAxBN5RqIrmpM4DvgJuCoYVUzdxaY2a6oJ90q7v7YcP5tT6C3d1DvFTNbGlGvvgzs6moRULjPqD1gooE7ByXNbxD7XkV+p23c/ddI3N4N+WfPdfdPipK3QmNQBW0qDIEov5sSOdC/RAvXooiXfV93PzHOM2Aad3+7IFGHikTJWQ8ZODOjksLnUPP4D3PnL40ads4IPAAc6O5vNFbqlpEE1RZHTpcDEF3drsAglHlzsLv/bGY9UIn0+ahM986iZAamBr529x/M7ApUqbWwu7+TnLckyrCcB/Ee34iCTYU2WkvGfBbEozoRqmSaCSmhNyLKm+eSv5kDZTm9VhkqFboakndiHJSNvy4q1/4dBbzPCgfc2MAGaC35Erg7n1VXoUJXQq6adCtgZnffKXfOHKjCdCWUxXkzsH2j1olILlgaJUvMhqhhj3P35039Mo5HVTnjdRW6iQrFI+yFlC5pDtQHbX7gWZRBOjXSA2dz91eKkrXsMLOx0Lhth6rRn0K0vLfmzssok0rbl7NChQrDh0hCnQvZ+OsAE6Ckxy/Qen5OZOYX9t4nQZv9UY/ajV1UyT2Ab4Drkd9iK2Q7HOfuhxYh69BgZmOixvcZe8n9wH5ZBXIcH4z8S18AHxURJOsIRMDtYrQur+3uH5vZRsCEqPLoj6H87QgFC1vz7EYV+Z7AYeiZ37at31dGmNn8wKju/qCZLYBshd2By8K3uS2yJdb3hKKvQtdFFbSpADQLcGyIItcbZdUzEfFdDNgRWARV1pzd8n8rHoljcU4UzHgTBaH6IZ5NULbfnvmFxWq8sRe4+xaNk7p1MLOnkJN0JXd/z8z6At2Bn5LKovmQ86W7uy9QoKxzoN4WX6KgxyUoQ+jsyMjv6UkfIdSsciOkJK3k7ncUIXceMeaOaG1uM7O1EJcowEsoOHZ3GoiqUKErIjHGbkK0S7ehvmAroyDyqihLP3POjTo05b5Cha4GM7sBmAL4wN1XC+O3h7sPjOOG6GV3AL5rdEVLOE6mQ/3Ytkbc4KeidfoE1K/wP42UqcLIARuSLmld9MyNH6ec7e7bFSRep0KdAOx1qNfFa5leXaFCRyF8A7Mg6s/3vZNQi3cVhB7RA1XV/QT8XCaGkKhWuRpV2uzn7t+b2WnAiqjq9zfgPGBhRAO1jbufW5S8KfJBAzObHM21OyHd6XykJ31ZjISNgZkdDByMEnkeAz5BFdrHeAf0Jk3txdYGHc1sN+Tv2sLdL2hvmRqNetVCJkagFxCl4DmmVhV7o6SNmbtKoLDC0FEFbSo0g5mdgwI0S7j7Jzmn+ozIUT0q4jr/vkBRWwUzewhlc+zu7i+Z2TKosdcjwBIo42N3d78s93dnoADV8mWIYCeO0gmAS1HE/WxgUH5RM7O5UOBtLGA1d3+p4QLXZBkL8ejvCIyD6Bw2dveHknPyGZjjoVLccxovcQ3JmC+Lsk22c/fr49hzqBz9chSU6o8ycG5CTRSrBbRCl0MS3P8XcC+ifsoaJD6Asv02dvfPYq76yd1/L1DkChUaCjObF7gV0QKOBmzutf413YFuiU7VH63hvxUk6+jAHIgCZDW0jn3i7pMVIU+FkQf5TFwzOxwFHyYu6n3ojMgFYLdB1GinoYrXz4qUrULXg9X6lMyFnLfLAH8gJo5nkeP9xQJFrFAShH5xEQombR7+gPeBw1EP29/NbGfUI/lQL0HvXWiW9Ds6MCCbR03UdNMjitutgW7oHTi7IwIYZUAE3i4FVgE+RQnCK7r7Cx3wXeOhBI4rgHsTPbleECPzzwwAFkDJglvnz+ssGFaAykQ5fjvS189AjEDLIlq4qpfNSIJuRQtQoXT4FmXNfAcQpfXdY9J8HU2oU6GAQKlhZv+H6KwuBV6N3UejiW8rtNiOA1xiZh+ZWV8z6xaT4yjAb2UI2ADE4mSo4b0h2f5O9qcYB2Xd7FNkwAbA3b9z9+NQFkRvlE15gZltEws0Lgwys56mfkq/ZwGbLCuzINmzBXRulIH8Tsi0PsouO9PdbwMOBXoho3nJKmBToasiUYgXAz5ARjpmthrKljsWUQSAStbvC8d0hQpdFuka7O7PIPrSW5COfY2ZnWNmU7r74NCpeobz66ciHdTu/puLp3xvFLi5G1GZVKjQofAajWCP+HwgMEEVsBk+uPsgd38N2WZrIYrSnYAXzGz1QoWr0OXgNRrPCxEt1yao0uNC1G9p3GIkq1A2hH6xJqJwB9nSfwBvRcCmF2Kw+AIl0pYCiQ1/EfJXLGdm/dx9oKsH4XEocHM7cCTwppktVoy0HYfQa/9A7Ccnot6l4wJbmtnkdXxPI4plEN3Xf4EjgyknrcpN9ezMP7M6oq47vbMGbKB2PWa2kpntb2ZnmPpLZsd/Rf1rbgW2QBT9x1YBm5ELVdBmJETmCDeztaJ6JsUDQE/g5Ci9JxwN2WTYA/gFKWulQ2SyZhgHBZc+jKyJVVB0+lR3/8DdD0JNva5AfJi/oLnzV7RYb91I2VuBzVCl02LAdmY2AzRbvIjPd6Ey3jI1IH0P9b/YEAXQzgCuNbN/m+jdAMZD17dP9keNXITNbDQzmzC3rxvwGvCQ1xpG7454gzPO9WeBx1FAatvk7ypU6Kr4GhjX3bNg+PFoHn0iKnH6o4ysH1D1TYUKXRkGonoys77u/pyL4mkt4E7UrPZeM9s36B/+9hL1OnP3b1H17mbufl/R8lToWrBAvWORsGORGNYls5UbgSQAuw9ysr2PenhWqNAuyN7hSFybBCUGXhJ64KIocJMl8sxr6lVaoQ1oab7spLblL/HzC+T0ny8+z4l0pJ7u/kMRgtVDMvYvAwuhxN8DzWy+qML52d0fRskuGwE/oqrqLgWv4TeUrP0cGov1gCeAXaJ6qr2+7xJgBtQveA/gYjPb1cwmy+QJXaE7gJnNjFhcZiw6QbmtiOvpEb+vhuzoA1Dl+91m9ripjzWunrA7AtOi5/KQQoSuUBgqerSRFKaGsx8hpf4/wCXu/k2Ug16Asgguit/fcPfvIsBzODCLu09bjOTDBzPb1t3Pit+vQcGmtdz9CzMbH9FZnQZcGc7GEWqe1pEwNfZeEWXCLoAy6k4D/ucJBygJ1ViRsBqV0iipMW6iTVoW9RaaCVGM3YP62GwLTOvu7w6rXLQD5L0KlT5vkDijs/Lg/vHMTIIyHR7xaDBtZv8GzgTWc/fHGyVvhQpFwcwWAu5DCuRE6F3+F/B6vPP/h5T7y9394OIkrVChMYh17W20Phzi7m/H/l6I/mNzagbpuR60ghUqdGVYHWqTCh0PMxvX3b8uWo4KXQ+mPhdrA8u6mpPvi4KFi3rQJpnZuSiws467/1SctJ0bZjY9Sn4aHMkVpUU615v6HY2HEjZ7uvtf4Z84FdE4foECHQYs5O5vFCT2UGFiXjkVVZS9DZwL3Jbod92A8dz9ixb/SSdG5ocxswWB31FPmzlRUvPKKPH5COCuEU26SP1vZrYyqu6ZAlFxXwjcmc0l4ZfZAwUuFo6EhU4DM1sReC59bszsTeANxFLxJ/LzbYkqGK8CDnD39wsQt0JJUAVtRlLEhLcYsD4K0LyKmqxfF8cPQqV4g4D/oeDO3IjzfF13vzPoPQoNDiSBgb1CvuPc/dk65/VA1R2Luvt0sW9h4DLgIHe/qIFitxlm1hPR122AHKYDUcDgGuC9ou9HhuS+jI4WoJ5owfk5jvcEpkbP3pbI8fsdcIq7H1FE8MzMtkPP/KLu/qmZTQl86UlPjlA6H0d0aFsAA1CgaV53n6KR8laoUBRiPr0cWBzoh5qJ7uruA00NE/dC1QUTZAHlChW6MsK43w/YHrge2DGlejKziRAt6/bAy+6+eCGCVqjQQUgTbcxsNmAFpK9+jIL4n5Y1KapChQqtg6kPyZHu3ifWvS8QPd/R4ZyfCNnbg1GSZPXOtxJW66eyKNIVlkIMJ88BD6L+KV8VJ2F9JDZ/TxTAWwcF7b4EbgOudvenzWxyZBvMgmjcb3T3BwsSu0XYkP0HZ0W+lgVQkunlwP3u/nlxUhaHqH5ZBPWhmxv5oE5296fa8L/6okDQVKhq6dZk3PdEFPQGXAlc5u4PmHpH3gA85e5rjPgVNQ7BRJH1BzoAOAX5ku4ETnL3K+O87mhMVkVzQX8UQDwu86VVGLlQBW1GckR26OJo4p0PuAM52V9GVRCbomj6H8BLwEXufnsx0taHmU0KfAj8hrJY7wb+6+6fxPFMmdgQNZS/BXgeleX2cffJi5B7RBBBtxkRV+xaiKrrZKREFN58NBnzs1Fw8Fx3P6HOeaMgGrs5gB/c/dHY39Aqm0Se3mF0LICekyPj5/uJM2I9VIH2JwpG/QFs4e43lSGQWaFCRyLJvBoAnI3mn/cQteZnwLookHOQu59fmKAVKjQA+bXKzDZFDqsngI3yRr2ZzQd86+7vNVbSChU6FlZrUr4VsD+qbH8PJeX0AJYLWpns/KoKp0KFToao/ngI2ZyzIKft4l5r2L4sCtLu6+7nVe9565DYzaOiqo5vUd+UN1GFx8vA+mXUHRLZT0U2wbMoWLM0cjqvB1ybVFL0cveBhQmcQ65K6B87PhLUPJF7Z+AYZOu8AuyVVd10JST3sy8wP2Ih6Qa84u4PxDm9gGkQA8zOyO6bYHgCChGYuBgl8PZECeJHogDQX3HOAOAkVLH+Gao6mRw9VxO7+5cjer2NRCQzr4yCl6ug6pq9UALwme5+R+4ZHAWYFSVr74ASJE8pQvYKxaIK2oykyGXEdUNVD6ughl7jAGcBp7n7R6FA9EQN4gfl/75omNk8wGNoQXkfGBv1IbkI0Z5l1GHjoCDHKmiheRg4wt0fKrOzPaLy/4dKU3939+eSYwMQLdHuqBH4Ye5+SAFi/oNksZ8DOa72Q0G0X+P4AsBswGPu/kqdvy/82YosknNQQPMZREP3UJbhFMHOHYG/gAeyYFOFCl0VMdeMhbLjzN2/if0rIwfd5Chz6EWULXRbIYJWqNAA5Iz8Zk4pM1sH9Xl6Ddjf3Z8rs45RocKIIgnm90OOlZtQ4P4DM7sMWBJY3t2fL1LOChUqtB3hZO2Oqg42i93/QSwJX0WFyL7AZO4+fSFCdlIkc+jJyKm7gbs/Hk7br4DjkDP712CC+CxzbBeJRO5pUCDjEODEqLy/ENE7reyiPR8N+Kts1VfJNeyF7Prr3f3T5HhP1J+zO6qknhUYHQUNulQvtsSH0x8FSJYBPLa/ENvIXu7+Ypw/GsHE4+63Dud3HYeqsi5C1TrHIp/WtKgX0rhZkDKqd8+m1hPpYHc/vO1XWiwi4fzfiC5wlth9PrCdu/+dZ5wxszGB2bOgWYWRD1XQpsI/iODMrKix2saIR/V44AJ3/yXOKdyhXg+R2bM38BSquNkW6IPKWM9z97vjvO4oQDUI+N5L1PwuRZKxuCpyiM4J/I2ybx4FzvFovBbXNC7KVLjNS8J5aWYXoeDMuu7+pqlh3aZIoRsNKUB7uPvJZc3EMrOlgaPQdVyLaKCed/cf65xbynejQoW2IIL53WIeWgTxFi+IqDDuQ6XctyXB2BlQxeMgj9L2ChW6KhLD9mhgJ5R1/CbwtosGZC2U/PIosL27f1atERW6OszsQMT/v3YEK7P+mQcCZ7j7H2a2JaIDOb56HypU6Jwws12APYG+qLKiB3KovgdsFQGHKllhOBCVDbchXWL3CNBcDswFLO3uH8d5rwHHuvvFxUnbHPE8bIf6uz4XVcVPIp/SVWFLHIUoxlb2kvU6MrPeyGf0L2TfnAU84e7f5847E3jUg8aqqyHRbS9DNt9/USuBWVB1ywoogLMPcGlbfTdmNjXyae2JEnt/DjvyBuBG5NOaAFWYne7uV8TfrYd06gVH4DILQ9jWniTOT4l8rqsihqOzgAMz/2Q+eFNh5EW3ogWoUB64+x/u/jTiWFwLeAE1ArvHzJaJczyCBGXDI8DTqDna/xB12BWoNPe/Znaamc3h7oPd/S13f6/EAZvMUToKqvb4DWXd/AstlBsDV5jZAWY2TlzTF8ggLkvAphfiMzZ3fzN2H4Uqgm5AFSzXAgea2VhlDNgAuPs9qMppZ2oy721ms8f9Sc+tnA8VOj1MfOS4e1NibF+AKhgPQrzCy6Gsv1OSteGNqGos5btcoUJ7Ioza7sgBMSoyPLcFzjKzJ9B7cBKwEnCjmc1WrREVRgIYoo59OT6fCbyDnHZZf7PFkHO3b+PFq1ChQmtgZpb8PqWZrWVmc8Tv5u4nI13wfMTQMQiteau6++MAVcBm6DCzbtk4x5j+gubQPhGwWQBRDh+BKhizioPBwHgFiU3IkfchfoMSSDOb/xQiwSt8Gj1RwmZ31Be2VHD3v9x9EeT/mgZVfhxlZvNHBSlmNiEwKWJs6ZII3XZadI1noh4qH7taI2yDkpQGIkqvMUbgq85ETCY3RMDGkN48LaIOexwFMMcDLjOzY+IduaKzBmxA45v9bmbbAz8DRyP/2IWogvEtM9s2zh9sQuWzH8lRPQAVhoC7/+Dud6CMiS2B3sDtUbJL2SK+MYn/7u77oCDHhcDC7r4tily/iybBi8xsTxO1VZmROXYOQ1RE+0TJ6fPAFKjv0KA4fq2ZbROBntLcFxdX7YvArGZ2cWRsbIyyKTZy94dQY8XfgAkLE7QVcPe/3f1MlGVyKQrg3ISyhypU6DIws/GB+81s/6A6wMz+hYzIbdz9CHffA1Vk3ooc0ieZ2ZFmNguUb32oUKGjEM/62kjvuD22E4BXUXbiGsDniDripILErFCh3TGU5K1fUDX7aGa2ILAa4qj/Mv5uemBi4CevmulWqFBmdAcws60Ri8VVyMl6KbCdmU3u7i+7+67A3O6+hLvv612wx0dHwMwmiOSofDLHW8CCQZ90JKr+uC+ct71QwHsClKxaL3jS0XJPDjXnc/L9n6FA/Bpmtj5iCDkSOaUBZkA07m940CuXCVnwzN2vQ5VNR6GA2fXAkWa2K9LvlkesG10Z46PA4McZVVdUfAxy92tQf5UZgC3a8s/NbElEmXopqsTNEl93Q4wNm7r7JsjPsgMKBO6KqPY6LcxsGjMbPxLgNwcOBaZ29z/d/V5UvbQpSpo/w8z+Z2ZLuVAlRI7kqII2FYZAsnB9ClyCJs3TgJ3M7PSyVdrE5NcjPp6F+tucZGZTu/sD7r446j/SDUWzz0vOLx3iesZAZak3Il58kJLwGbofiyElejJEYbdkAaI2Q5qVFbgRZVIsBCyLFtwT4tx+KEPjb+DjBopJfH9e1mHC3b9x911QU74vgVGG/hcVKnQexDsxRmyHo3lyI5QR9wfwaZzX292/dPftEB/vhyi4f52ZzV+E7BUqNAr5tcPVBPVKtB4sgugzt3L3sBa0pQAANklJREFUMZC+cRZwF3BGo2WtUKEjEO/AnmY2W2RPp7gWBSqPR/rfHcCtSfX4v5DTsas7vSpU6NSId7YvstseQwkKayKd8DTEYrFOOCFL01S+MyAy7F82szWyfUnw5mgU6HgE2c/He63Z+gLA9sBT7v5U/F3DnLmm3sC3R9XDTOn3RzLmBcDBwOmoL8zD4fQfBwVAZkKBnDLiH9+Wu//i7kegBLWbgczBvjC6H/cWI2LD8AUajyXMrFcwugxO1vu30To/bhv//yzUqnW2MrNRI/FvC/R8PA1KAHb3O+O8Hijho1PCRIN2KHCOqfXBcSgQ/nocN3f/1t2vRknzuyK/5d1Z1U2FkRuldVxXKA5p1keUNr9qZgcA06HgQF/gxyJki0j/YDP7N6oA+tHVlKs36qXwsZltClwH3GVmm7n7I+5+gZldjZShl0MZLWUflUAPpLQNjrLRSVGztl1Rn4nvzexFlAF/etB4FQarcaCOCSzg7re5+6dmth+i2PvRm/PCLokW53Pc/SdrMGdnBMamAVYHzh9W1k9yfX3d/WUUuMmOVX0KKnR6xDP8BjCeme2AFOdzUZafAb/HeX+F4j7I3Z8Blo/gzqYoC7NChS6LbK43s4WBb1y0gI+Y2VsoyeUpM9vS3a9x96sjQaSHd7FmtRVGavwbZSGvA5xpZnd59FoIve8U5Og1tH5MH/rqjojC+GZ3f7IQyStUqDA8WAhVfhzm0XgcuMnUV+JE1ED8EjO7FnjE3f8qRMrOB0d+lG9ADl2v0Zt/iBy6ByK6qEPNbB5gTFS9OxAFbhra7yKC9f2AX1HfsgXDr3JtElQ6ESWTLgnMHgwtL8f5UwNHu/tHjZB3WEj8STMhVpaZIyfnWne/HiBk3c7MDgamR1Sf37f0P7sQPkPJRpsBj5vZ9e7+q9f6lU6AnsO2vu9nAS8Bu6CEpg2A/ihQeVP4HtPnuxeyQUdt4/eVAR8CHwD7ogSvHsD/sorjLAE9qpneM7NTgYdRsLxL9k+qMHywytdYobUws0OBrYBFiix/NrOZkRLwHVo0egEPosXjfkRNMi2i4/oINbsfgoah7M72iMp/4+6/RBnlQcAa7v5sOIIOAsYCdijLdZjZYagn0rXAkRHgyMqnLRSkNVC2wa/uPl8cb/i9iEDkYYim7RjgDq9xrtc7vwfqW7AEsKaXtCdShQptQf4dNDXlPAFl/ID4hfdw9T3LzumVZViWfT6tUKG9EFly1yM95HPgYuBR5KTeEmVjXoiM/ypYU6HLwczmRhWZy6C+BacDT7v7V3F8caQLLgr8gJK9eiDdcDt3/64AsStUqDAMJM7sAShAexgwZyTYjZKuaWZ2BLKLugNzuftLhQjdCWFmY7v7t8E88QyqLjgpC45FYuFeqK/qBEi/uAG40N0fLzLx1Mw2CNkmQLrPlaii8s84vjVyyI+JqvffAU4GziuDnZAkYg4AnkQVHB+jwMBc6Jp2d/fn6vztSGHrRBLu1WgNvxIFaD9BVeUHIZq4yYeV9DqM7+iHAmbboArcx4Cd3P3F5B6NjgKY2wCTuPo+dVqEbnQfCty+i8b1Ond/J44betfHQX6zL1v4VxVGMlRBmwqtQtAaXA30d/dFC5ZlZ8QPPxhlgn+EFtm+iHrhGxTMmTb+ZBV3v6XR1RztgcwpamZLo6yHrdz9PDObA137B+6+VrFS1hD0SGsDK6D7cSlweBY0M7P+yBHcAzjN3f9X1H0xNVxfBPGlzg/cgrJHn/PmjeIsMiDmAS4Dfnf3ORotb4UKHYHk+R4FlawvDdzi7q/E8akQ1c3KqBLnPNQ48qM43h3pElXD2QojDcxsY8SvPQcyNr8FnkW6xxQoi/Ywd3+wKBkrVOhoRADzcORguBzR4j7v7r+Fs2Vh5Nz5EGXWPlpl41eoUD5Ecl3aq+R+1JB9ELCxuz8a+w3omSTsTAjs7O57FyJ4J4KZ9UuTSGMspwBORZUcf6A59Cx3/yLOmRrpFU0u2vpCUCexqxewN0rmbUJUmNdkOk9U5M+OHP2/lcnZngQELkLVZHu4+01mtgTqTTgQ6IN6E+7l7j8VJ23jkQRuJ0esKJuhNX4gqnb5EDjW3c9uh+8yYFJUbbMdMDqqvjnT3T8z9ca7DTjBRVnXKRHza3dgRmB/FLjZHtndj6JK/Zvc/Tsz64OSicd19zULErlCyVAFbSq0GrEA9/XmNFdFyDE56veyKbA4cD5wNuLY/BNl/vVFE2NPlNnxbiHCthKpMhTjPCDNXjCzKYArgAlRZH4SVGUzl7t/2HiJW0YsTMsB66P78xNa3M+P4z2AMUYkO6O9ELJODawCbIv4Wc9BAaUPkvP6AYegzKHp3f3trIy10TJXqNARiIzJbVCm0/Hu/lgaUDVRUp6KDMx7USXBnSObMVNh5Eaa3RrrxwTIuN8EBf/HRrztIIrTcb3i+6/QxZA4vWZCAf3MmfIxCuxfC7xX6UgVKpQfZjaju7+e27c5snlmAl5BjsZHkiS8IRJ2OmNyZCNhZk+jxNKd3f293LE1UaXujIhG6RJE392UO6+hlR4tJHbd7O6vxvHJEHvGiohW60YUvHkt+R+lsZeT65kGeAAlAZ/r7r+a2TWoFcAByKG+NKq+Oc3d9x1ZqmxSRABhMuR3mw3RJT6Q3f92/J7uqIfQ9sB6qI/q6SioNp+7T9ae31cWmNmuaG4dFSUP3woMQNe+rqvHTYUKVdCmQudETO7TACshnuwxkKF4fJqJUiZFoSUkxu8oaKHaFAVkfkCNXG919bWZHWW1TIGqi65095uKkXpI5BV4MxsD9YzZDDmz7gVOdPe7i5OyPsxsVKQsbIho9X5AWQ5XuPsPZrYcCppd6e7bVYZJha6AJJtqC+R0uwzYL3Uy5591M9sTGWiDUKbQ/u7+RoNFr1ChYahnqOdpYmLfGEgvGR81rn3Y3U9snKQVKnQ8knVjfkSb8gGi7emOHDurAy+gZuWPeq1XQ4UKFUoGUw/DU4Fd3f2U3LEBqJJif5RlfwEKyL7oQ/adqDAURPLfbsBGKEHwBGQT/5Sc0xeN93pxzrPAGe5+f+Mlbo4WErvSJJZFgYORY/9FxM5ynZeMCjMJ2qyD2DU2c/eHzGw2tG6t7e7Xmtn4iHL/d8SwsUiBYo80CF/Y4sDOwGKImWUVd7+lUMHaCWY2rrt/ndvXH/gPmht6A3+jpMjVChCxQklRBW0qdGokzvaNYvsROduvLJui0BISA/hsYC1UMfQSolyZFWWv3JkoRhO5+2eFCRxI5DZgPA/ezagUakoy9GdDtBkToUZzW7j7BUXJPTSE0+3/kGL6b8R1ew66B8ugrOm/rEAu4QoV2hMRbP0SGViHu/tX9Z5vM+vp0YQyFMwzgXWBcTrLXFuhwojAzJZCFaQzoV5oTwB3laFqtEKFRsPMnkQOre3d/c1YSxxlJx8LTAlchTJH73f3XwsTtkKFCnURSWlbA8e4+5NmNo+7P5s7ZyrENrA+osk9G6197zRa3s6MoIycEfkrNkVVNweiBMGUlntqVHGwPAqGP4zm2Yb2yGtjYtfmwB6I8eQ1YB93f6GRcreEsPH/RHRu46Fk3zUiMfYyRKu/hrt/HEG2F5Az/Vp3/7EgsUuBRvs9TD11NkL+pX0b9b3tjSx53MyWRMlcU6Ie3Ce4+825c2dAyeivAk9VtnWFFFXQpkKXQB1n+zOIZ/t+Lyl/tpkt7O6PxO+zo4yafd39+Nh3JyqRXN/d3zez/mWkIjKz/VA1zTHARYlj95/gTWRybQfcDRzg7r8VJnArYGYTI8fDDsDMKNNjB3c/szNUb1WoMCwk2WY7IQNrI3d/aBh/0wOYNMucrpcxVKFCV0JicC0KXIMqzJ5C+sZglHV6OUqsyDKPe1WUaBW6EvLVZkGJ8whwr7tvkT8XWBa9L6PH7knKkGxUoUKFIWFmo7r7H2FLv4VoDg9w97ty5y0KHIn6ub2K7NPXqTBUmCjOv8iCLmY2FhrDbVEP2EeQ/f9k7u8WQVRdr7r7ro2V+h8ZWpvY1SPRgfqiIN/awKxeEK1+wmQyG+qZsi3wMmIJSPsGjYYCOOO7++KxbxbUJP5kd7+0CPk7EklArq+XqN9QitAlundWn0tiZ/dGDDmDUGL2GKgi7Un03j9SoJgVOgm6FS1AhQrtAXf/wd3vQIGBLVF54Y3AzRGtLxXMbF7gXjMbN3atB7wJ3BnHF0GVHScg5RlgXzO7MEpHGw6LJpVmtpaZzZgc+gVx9x8IXG9mywO4+9+5kvlnEJXSb9n/KiuCYu8SpOQdg7JszoxjnVJ5qFAhRSiShvpjDUTzT6YkD4HY3w84JCoOqAI2Fbo6kvn+DFRds2pQFuyCeswtg/rqnRB0UVQBmwpdDbFedE8+f4RoZKfP1owI6uPCnShJZ19giSpgU6FC+WABd/8jdvVE69lg4Aozu9LMpsvOj8SeRYGdgL+rgM2wEQHux4F9IhCAu38Xc+QOKOmxH/CYmZ1vZpNkf+vuD7v7UsA+8b8aZjsntsD2wB+I6uyrkGuIiotIbulhZlO4+y/uvjvFBmwsAjbdETPARiggOTqi+zs3gjW4++/AJ8CiZra6qVfbnsD0wD1FyN+RiGDW4FizzzazS+r5ylqyBxuF0CU6rc8lSXTZA/nK1omg4BqIir8n8FCM/+TFSFmhs6DUjtMKFYYXOWf7SUC3ohSGYWAgmqyzks9fgdG91rjvFEQpcV8oQqOhXjajo6qPhiOUn3GBi4GHzWw3M+vn7qcBqyBu8+mA083sbDObA/4pq18ImCUUo7oKX9ng7oPCIDkOBQKzjKMKFboEQqEcBRjgQW+YZlPXOfdvVLo9XsOErFChICTO6FUR1ceZ7v50HD4C+C9yYH2M1ogTzezgzHldoUJnh5lNbmbbA3iN8rZXHL4WWAD1Mcicdt3jnDGQjjuJuz/YcMErVKgwTIRT1JPPXwcV0c6ICmte4EEzO8pE7ZUl5J2F+ldRrXctI3SIX4H3gYOA881sSzObFMDdP0aVuhuieXQ54GUz2zsb78DAOL9htvMIJHYdmiR2Fel/yeQ8CV3DTmi9WhU4HrGybJ6c/1/Uw+YK4BWUkHNAFqjqYsjG5hhUNf5pvXvVkj1YYdjI+Ys+RpWJ/wNw9/eovff7od49L5jZsdV8WqElVEGbCl0OibP9CNQQtXRKpbu/iBo6rm+i4noFmNjM5jWz7RCv6tEoMg8wA+LB/cCL5QX/FWUI3IsW+8fMbC13/9jd90aZA08iarHbzewhVD20FiqV7nSBD3f/2d1/jt+rZpsVuhqeB8Y0s2WglnnZwrmzAp9TUOC4QoVGIjFYp0Y86Bkt4A4ocPlfd38JZdH9DUwFjNKZMwMrVMhhK+A0M3swccRllWRnIcfuQWb2gJktFdm7A4CVgYWBd4sQukKFCsMHM5shCcw8BewW26PIuf2smW2ane9BhV2tdy0jYmLfuftCwJJAH9Qn9RQzW9nMBkQQ7DXgZGBN4DpEifa2qd9QYc7zzprYlVTZTIWqmU4CbnH3v1z0zlch/8oc2d+4+7tx7oaox9Mq7n5S46XvWCRVNlMidpqzUd+ezP5b2sz2M7Nd4pwKbUCS5HIiCgCOCvxlZt3iHjS5+1soSXt1lKi9eDWfVmgJleOlQpdFGtwo6SR4GFJuDkIVN28iZW4yxKP6fCys46NAydSILq0wRKXM7Wb2PHA7UnCuMrMNgSNC0X/KzP6NslhmAD4A/uPut8b/qAIfFSqUB48A3wJHmtlH7p5l03VDTaWzjLtewJzA+KgBe4UKIwseA3q7++sR0NwC9et4K45/ixrWroe43ytU6Cq4iFqyztVmdjdwkLu/4+7fm9nhwI/AasDdZvY+WjcmAV5095MLkbpChQqtRthstwIHmNm1wIcRlLnZzJ5ATsW1gJPMbCtgSS95b9KywNTf5Vd3fwCYMZI+jgIWBy4ys2uAZ8Jn8biZvUPcCxQwKRrPA9ub2TLufneW1NVC8KYUiV2JbOcC7wC3uno2Zb3ZPkb9Rd6CWj+ecKK/VfefdhEk1Vqboz4rd7v7z5FssSNKsB2I2gxMb2Y7ZgHaCsMHE9XhyohKeTCwrrtfHse6u/tgFzXlM2ZWSM+qCp0HVaVNhQoNhNXQE/GnXoOo3MYH1kd0EgOACVAVzpIoC2JzFBQptIdEoqx9gejQNkZcuzOjEvpTzWwSd78d2MndF0NNFi+Mv6/mnAoVSoQo0z4WBWSuNbP1zGz0yAJKqTP+hRT629z97aLkrVChADwNnBq/j4eM/e5ea946BaqOnaYzUH9WqNBauPvb7n4Uysi9FK0TD0Um7qgRvNkJ9WU4DL0rn6IM/fWLkrtChQpDR66i+hPgDcRQcTWwkZmNGxnh37j72aiJ+wXAXa7epIX2uygzrNYDdnnEStHfaj2/TgfGQVWKOyLK8V3NbIY4/jUK2qzk7jcWIH4eaWLX9JldEBUD/1Tmly2xKxzmkyH9bHsTJV3mg9gofr8Baom9I8MznVzjT8CYwO/x+UhE83s+ouI/CFXaztxoGbsK3P0TlMx1DApmXmxmJ5lZ/6QSp3uc+527f1ectBXKDqvoCitUKA5mNg5wB/CSu28RVTW7AtsgDn2QAXyyu59YkJhDhZmNirJrNkRBnJ/QAnWpu/8Y55hXk02FCqWFme0PHI4U+FuBmxG14TjA3MCBQHdg3owusEKFkRFmdhMwC+Ki7oUc1uO6+0xFylWhQnsjy0CO32dDFD7zIqqP14AT3T1LyuleVVJXqNA5kL2vZrYtCrA2IR1vVGA24GFEm/S0u/9U5++6VUkKQ4eZfQa8DGzg7t/lq1TMbFpEM7kY8Djqq3Kfu39ekMh1YWZ7oOSu1xB1+835SiszWwJdy1PuvlHjpWyO8E3MjarENgd+QBVOd6PeImcCh5SUiaXdYGarAN+j+zIwt/8GRH9oqPfwwcBJ7v5rBBwvBDZy97sbLXdnRzo/Bu3kgsC6wDrAz6hi+Zw4XvnIKgwTVdCmQoUGwcxWR9kL4wF/oWwUB7ZHPLe7A6dGBstoiAPzfeBL7wSN8EyNZ/8PBZz+DTyDFKK743hl0FeoUGKY2Xwo03KJ2PUrmrMMBXFOcfeHipGuQoWOR+KQ6gtMh3rZALzr7n/GOUsiY3YsFLR5H9jM3R8rQuYKFToKWdAmHLubIcfu+cA8wPzApKi65mB3fzL+ptL1KlQoMTKHoplNBryN+iocE4GFyVE/qr1Qn7azUTXI6+4+sHq/h45Eh9gLUZ+v7O6PJMcncvfPck7dFVE17/goWLa7q89NadBZE7tyvokVUC+bP4GFgw6ty8LMegMvoff4BBQU/CB57tZG7/kg9J5f4e5/hf67NbA3MIe7f1qE/F0NkZi9OLApsrMzP9ldhQpWoVOgCtpUqNAAmNlCqMR4EFIYRkWR9j+BLxC1Sg/EHXti1v8l/rZTZTOZ2cTA0qjfzazA6e6+S6FCVahQodUwswUQD6+hOesx4M4qE6hCV0auquBmYFlEWfohclLc4u73J+dvjtbxlyrKwApdFWY2CvAZcDlwlEdDajObBfV32gHxtf8XOM7dPyxI1AoVKgwHzOwwRH24jLv/L9nfHTVpvwzZp5+hDPwT43iVGV4H2bhEZv03wOnAYR49ds1sXUQzOb27v5sPgJnZAYhaclJP+vKWBZ05sSt8E0uhaoclET39UcCrncnHMrwws2kQHdxOqOLmOOAm4Iuk4msMd/8h+ZsV0bN7i7vv2HChOymSYPg06BmbFngS9Ul6LbEvpkP2xa5AP2DsrvwMVmgfVEGbChUagOBSnQD4CjV4c9S8dYC7f2FmUyHFeU2kAN0J/MfdXy1G4uFHqsQHd+/0qCR5Z1SGvHOVnVWhQoUKFcqCqGqd0N3fTfYdgHq1nQvcjhzTS6P1+2bgGnd/oQBxK1RoOMxscUTju727n29mvXI0K3uhLOu/0Dsya6XrVahQfpjZdsg5O4e7v2Rmvd39r+T46sD+KFt/Q+B6VFX6W91/OJIjqbK5AFUrrZLZ8dHn5k3U72U7d/89+bs0YaRXVDT9s69s6KyJXaZ+wjMAq6DKm9GB04Cz3P2zAkXrUES/odlRz5rNkF57FvCY13ozZueuFsc+BhZw978bK23nRPLuz4gCgtOipOxJgKcQFd3t7v5Gdj6wAPB7GjCvUKElVEGbChUKQhKRT0ukF0F0aQsh6pU13f2WIuUcEUS20bXAlMD8WY+bChUqlB9VNmWFrg4zuxqYCfVhu93dvzezG4B3aZ4hOx9wCKKEeg01a76xoo2o0NVhapD9CqqyOSjZnzkXx0LOyGuAG9JqtAoVKpQXZrYYcD9wtrtvl+zvHTRJKwCHocSFFdAauLW7/7cIeTsDzGwmNF/ujaqTsmDMASizflF3fyX2ZZU5owFTAJ9VdnLHI3wTcwCbAGsh1pNt3f36IuXqCCTBhAEokHgQMCdKsrgGUSO+4u5/R1BrNWA+4Cp3f6YgsTstzOxxRJt8vLtfbWZbIeq5JkR9eDFwf1cOElboGHQrWoAKFUZWZIGaLHATvz/s7mshHtyHgQcLFHGEEdlYzwL9gXELFqdChQrDgSpgU2EkwJMoE+484HQzWxoZsz1czVh7R2LF0+6+HEqqGA015T28MKkrVGgc3gVuAXY2s1XDwUhSbdMPBTJvqgI2FSp0Hrj7g8CJwJZmdoOZLRj7/4r3fDpku33i7ocBnwArRpZ4hfpYOn5uCKxgZj3MbDxk15+IAtxpwMZQH9gr6GR2csje6eDuv7l6EO6DqMPeR1RvXQ5J1evZwNGo6uNQRGe6FHAvsK+ZTRFVNdcAe1cBm9Yjew/MbBlUYXOsu18dhzdHVTbboGqno4FDzWzFzPdXoUJrUFXaVKhQIqT8tmY2ikfj486K4EK/Gujv7osWLE6FChUqVKjQDEEdcQIKyHwe2//cfdv0nMxJHdmIRwDPdMXMzAoVMiSOxUWRM2cQcDJwF+JoH2xmuyNHxJKeNNyuUKFCeZFk4E+Gsu/XQrTdzwD3oeDDUsCV7r5l2HP3oIzxFfO0ShWEGM8FUa+v+RGlXB+UHLKcu38S52Vz62SoX9go7j53QWKP1DCzcd3966LlaG8kjC4rocDBRu5+RRwbHZgGUdhvDDyOKIHvcPfvipK5MyN6hK2AxvnV6GF1EdKNHjWznVDCVy/gPHffqjhpK3Q2VEGbChVKhixi31Wy3MPB1dfdvy9algoVKlSoUKEezGxaxO+/ZOz6D3CuR2P1yIrrXnF8VxgZEb0XTwWWAz4CvgXGACZDtGhrFyhehQoVhoJc39FRgcHID/RX7FsL2BT1/JgI+AUl3e0SlTdzo8DtXSmVWoUhEbrC1Kh3ypbAVCgQto27v58EbHoDW6NA+Azu/laavFmhQnvAzE4E1gcWd/fXcnPBlCiwsFCcfkhU1VUYDsQ7vx6wkLtvE/teAl4GdnL3H8xsLuBI1MP664x+uUKF1qAK2lSoUKFChQoVKlQYqWBmMwM/u/vHuSrXJVHwZlpEHXERyj78KY73rAI3Fboikuz7cYBFUL+n3sCj7n5nJOEsBmyFMse/RdRpV1e9GCpUKCeS93pclFW/LfAN8Crq5XZDdh4wSxyzrGdbJDTsCawBTOnuPxRwGZ0OERybA1gd9QX6EWXaXxFO3FnR/HmPu29VBWwqdASSvirzu/szEWCwROddFjgAJWXcVyXZtg3RN6ivu/9/e/cer/lc73389Z4ZpylMhLjTJrakCJV2u92duyhFspUQOjjccogSHaS7KFQ6oYRU7kybckiE2m2HlJDs7Gyxk1N0cNiMcaaZz/7j+1u5Wo3DMrPWdV1rXs/HYx4z8/v91rU+lta18nv/Pp/Pzd1DLmfSdl9+pDv/JtqIxK2q6t/7V6mGkaGNJEmSJr2ecREb0UacPQ14RVXNHn3DJMkHaIuXA5wIfJN289qbKpp0er43lgbOAjagzfm/F3g2cBSwT8+YwKWBe0b2M0oabElOBzYEfgbcCbwSmAqcBxxVVZf0XDsS9Iz8/FsHOLyqjpnouoddkmVoo9LeTdtfcwnwBdoYtZ2BZ3bdTFN8P9WClmR14ELgFmCHqvqv7vjI9/i2tP0+W1fVNX0sddLoAvDLae+zOwPL0kbR/VNVrdLH0jSkXIAkSZKkSa0bCTG3+4+pLwAPAHt3gU1GhzFV9RlgRdqImHcCJwMfcwmzJrkvA88Cdq2qZYD3d8dvoAWYI91md3uDURpsIz+vkmwGbAJ8ANi0qrYH7u4uewNwUpKDkqwMjy4w78YofQrY3cDmqamqO6vqbNpYpF2AJYB/od3E3b8LbKb5fqrxUFW/BQ6h7bA5Lck+SZbsApt1aEHiUgY2T17P+2q6DhuSTBs5371/Hk8LyS8Efkj7Ou83waVqkrDTRpIkSZNaTyfB52ljXnatqnNGnVuSNvZpDnB/z9LgdWnz/Gc671uTVTfS4+e0uevHVtW9SU6k7bl4Yzf2Y2ngw8ARVfWHPpYr6UlK8n3anpoPVdVNSbYHvka7qfhc4BhgdnfNXlX1w37VOpl1N3bXoO2/+Ht3gWlB6t1XM49zuwP7ACvRvtevonXQPQ3Ypaq+NWGFThJJPk0LvZejBTOnApdV1R+78y+ihbN3Az/qwltpzAxtJEmSNOklWQG4GPgG8Lmqur/n3Aa0XTYvAW4DLuuuO6Oq/tyHcqVx8Vg3drpFud8DdquqM5O8mrZA+63AaV2w+XZgf2D7qvrFhBYuacySrAScAvy6qnbujl0HXADsWVUPJDkc2BL4I7CFgez4SrIUwLxGs0rzK8k/0cLYKcC1VXVRd3wlYCfghcD/Am4GTqyqM/pV67DpechrR+A42rjDa4DX0sagnQrMBC7u2YXp6EPNl2lPfIkkSZI09FYGpgM3jApstqAtCF0Z+D5tj8dWtCcSLwJunfBKpXEyEtgkeR1tT9PI98JdwNK0mznQxgieAZzb3aRYjLbfBtqsdkkDrqr+0IUyvwdIsjnwDNrIz4e7y2bRAtsPV9U93mQcX1U1u+fPBjaab92IvT8n2Zr2ANKytO/vW5NcDBxcVVcCn0iyVM9oYJ/gH4Oe98W30r7On6iq25MsTxuB+H5gY+DrSU4DrqiqR/pTrSYLd9pIkiRpYTALWL77BUCSLYHDgUVpY9PeUlVvA3YD1gN2nPgypfHRM4t9T+DTPBrQQLupez6wZ5KDgNWAT1XVXd35FwLbAj+vqusnrmpJ8+kUWpfpiKnA3G6vxbK0BxTWr6p74K9uTEoaAj0d4Z+jdYq/HNgMOJvWQf6vSQ7r9tmMhIbuaHzqbgXmdIFNquq2qvo4sD5wLm1/zbeAnZOkj3VqErDTRpIkSQuD3wHfBQ5IsipwPXAAMIO2s6N33vRFtM6DRSe6SGk8dDcW5nR7FQ6ljfD4SxdZtxB7L9oT9wcAVwB3dHtsVgUOonXabDTRtUt66kZ1c/yGtrtmn25c0trA9sAe0IJduz+k4ZNkTeAO2vjfS7tjFwCvB7YDdgDekOTIqjra0b9PXm/3YffwyxnAWtC6l7tgJlV1LfC2JMcBXwWWsJtJ88vQRpIkSZNeVT2c5HO0TpudgMWBy4EvVtXZo0ZFrEgbLTF73q8mDZ0ARessuws4tndMT5KXV9XFSXajdZhtTXti9z7ak/i/AvauKscFSgMuyfNpYetdwKyquro7dT1trM8ewBHAI8DMqvo6OK5LGiY9O1aeQeuOLVooS5LFq+pB4MwkFwFvpo3+PSrJrKo6qW+FD5+RsbK7AtvQOmqWTDIb+GbXkVxJptBynPOSrOH7qRaEGPxJkiRpYdE9Efca2u6aa6pqVnd8ZCb40rRl67sBz+69sS0No5FAMslqwLXAvsCXq+qh7vyHgEOAVarqd90T+OvSbkysAvw7cEZV3dKP+iU9sZ6fYVvSgpln0W42XkHb13ZCVf22u3ZN2sjDXwM3d7ts7LKRhlCSY4F3AHcD76+qE7rji9CNQuz+viawcVUd2bdih8zI+2KSjYB/BX5Le6Blc2Ax2hi0mcAFPV9n30u1wBjaSJIkaaE1ehlrkp2AT9A6cD7Tv8qkBSvJubQRZ5v23LydQQtyjgE+2T2ZK2lIJbkBuBE4CliCtl9hVeBK4F9o4c2snutdSC4NsSRb0TpkN6QFCfsDX+h5MGPRqnq4fxUOvyRn0jrw96+q/0qyHO1hl52APwLHAydV1ZX9q1KTkaGNJEmSFnpJpgN70zpsflFVW/a5JGmBSbIycD7wHODLwOFVdWOSY2idZxtX1Q3dtSOdOX+Z4y5p8CVZG/ga8IGquqDn+PtoP99m0N4HZlbVqf2oUdKC1/1/2HcAuwCr00aafr6qTuvOB5jqLpsnr6fLZkng/cD0qvrAqB03a9M6G19JC8a/DnzJThstKFP6XYAkSZI0AFYCNgVOof3HmTSZ3AG8i/b0/c7ABUkO7Y4dPDqwATCwkYbOb4DlgJEbitMBquoLwMtoY3xeAZycZJN+FSlp/nQhzF9U1f1V9RXgLbTO2RWB45KclOTF1RjYjEEX2CwOnAFsCTy9Oz43yaLdSMorq+pVtJ1Bzweea2CjBclOG0mSJIm2EwBYvKru7Xct0njoFha/HHg38GraKJW3Ayd7Q0caPj2dcSsDy9AeOvhxVX2tO78IQFU90v39H4Bdq+pd/apZ0lPT+2BF9/N8c+B+2uiui6rqju7cK2k/5zcEVgDeXFXf60vRQyzJK4BzaA0P04E9gKN7/h0sNjKGrvu7+2y0QBnaSJIkSdJCJMlzaGPRdgVeCnwbOAy4wv0W0nDoGd/zEuCrwIt6Tn8S+GxVze6uXQx4eNQON28wSkOk53t+d+A9wPO6Uw/SxnN9o6qO7rl+W+BtwFur6oEJL3gS6MKxfWhf7ynAqcBxVXVRdz7AYlX1oDvCtKAZ2kiSJEnSQqZ7An8N2liPXWmjP44EvlJVv+9nbZKevCSXA0+j7VZYhNY9txptXNoXq2pmz7WLjHTdSBoePYHN84BfAj8ATgKuA7YG3gQ8i7ZX5VNVdWv3cX7PPwVJpsCjo2KTvAA4EHgd8CfgZFp4c33fitSkZ2gjSZIkSQupJE8D1gPeCbyV9sTubi4qlwZfkucCZwEfrapTumPPogWx29Ju4l4IHFZVP+lboZIWiCTfAtamdc9c03P8BcBngNcCO1XVN+2mG5vRnTLzCrySvAn4CLAWrbvpO8Dh7gHUeJjS7wIkSZIkSf1RVfdV1U+BD9Ge0L8ecK+TNKBGlpB3v08Drgbu7I4tWlV/qqoDaaHNKbSxaT9Osk2fSpa0ACRZkra76s6RwCbJIl3YcBWwGXAJ8LEkSxjYPHmj9gVtmuRLwHeSHNiNSAOgqr5XVRsABwDrAOsZ2Gi8GNpIkiRJ0kKuqu6oqtOBzavqh/2uR9IT+ihwDe3J+nUAqurhbn8NVfXLqtoZ2As4Hfh+n+qUtABU1T200VwvSLJakilV9UhVVRfYFnA5sDjwzL4WO3ymACR5D3A8j3Yq7g38Osn7us5kAKrqi7QxlHtNeKVaaBjaSJIkSZIAqKrb+l2DpEeNdNaM6Bnf85+0MOY+4NAke3bnH0ozEt58D9iqqu5NMnXiKpc0Ds4DlqV1xz4d2v6VLrCdDjwEzKGNOtWT0H395iSZARwCnAmsU1UvB74LrAB8FrgkyWYj76NV9Sfg7j6VrYWAoY0kSZIkSdIA6p6i//skH0qyXM/x04DdaMux/wM4IsllSTas5qFudNK0kTFJjkuShkdvYJtkEYCqOoE2mmsH4MIkWwArJ3k6sB3wDuD0qrp94iseTj3jzfYDbgKOrqrfJ1mB1nFzILALsCZwBvCDJGt3H+uieI2b+L8vSZIkSZKkwZTkAOAg4BfAp4EfVtW9PeefT7u5+DbgucDJwL5VdXMfypW0AHQdIHOTbA6sB5xbVT9NsiywFbArbTTiXd2HTKfttNnYgHZsutFnxwJ/BvaqqruTfIv29d2oqm5N8nHae+xStPfXmX0rWAsFO20kSZIkSZIG1zeA7Wk3FE8GZibZoOfp+6ur6v8BOwFfAzYEbkqyQ5/qlTQfkkztApt1gK/QwoPrAarqv2kBw9tpHTen0UYl7gS83cDmyUsycl/8IeA64KYusPk74PXAMcCs7pqbaOPQNjKw0USw00aSJEmSJGmAdTcXVwe2oI1FW552Q/FI2o3Gud1104HNgXcBu1XV9X0pWNJ8S/IT4BHg/VX1y+59oEaP5UqySFU90pcih1CSFwKzq+p3o45Pq6o/J3kpbbfNflV1QpLFgR1p76ubVdWtE1+1FjZ22kiSJEmSJA2wqppbVb+hhTTb0LpvdgF+DOzWjUyiqu6vqpOArarq+p4nySUNkSQbAGvTumiuhL+8D1SSqd01SyZZxsDmiY28FybZCDgOOCvJUr3ngJEupdtoY9C2SjIDeDOwF3CDgY0mij+8JUmSJEmShkBVPVBVlwIfBbYGrgCOAL6f5A1dpw1VNbv7fe5jvZakgbY4MBW4uev+yMiJnhFo7wJ2T7JEPwocFknSjZubCnwBeADYu6pmj5yD1sLU/X4TsDvwj8CdwAm08ZR79OUfQAulaf0uQJIkSZIkSU9eVd0FnJ3kV8BrgT2B7wLnJ3lbVd3Z1wIlza/bgLnAK2nf2+mCm+q6bWYALwOWBtx98fhC+xodRvt6faCqzus9l2RJYGXaOLp7qur4JNcCa9ICmwur6vaJL10LK0MbSZIkSZKkIVRVtyT5JnAJbTH5+gY20qTwO+ACYI8kP66q7406vz7wKuDLVfXgRBc3TLoumxVoO8G+Shsr2XtuA+BLwEtoYdnlSY6oqh8CF/WhZImM2l0lSZIkSZKkIZPk6bT7PPeMLNTud02SxibJlJFxXUlWBk6kjek6HTgYeBBYD9gXmFFVq/Sn0uGS5CXA94F9q2pmz/EtgM/TumzOAe4FtgL+E9jEHTbqFzttJEmSJEmShlxV3dvzZwMbaUh0e1VG9qnM7Tl2c5JdgL2BNwOX0UamTQEuBN7Xp5KH0Sxg+e4XAEm2pO24mQq8BTinqh5Och5wLLAjcOjElyoZ2kiSJEmSJElSX4wENkneSOvyeBFwVZKfAacC7wVOAlYA1gCuAn5aVbf1peDh9DvabqADkqwKXA8cAMwA3lhVZ/dcexFwF7DoRBcpjTC0kSRJkiRJkqQJNjLKMMn2wGHAw8D5tJFo29BGHh5J22+jp6jroPkcrdNmJ2Bx4HLgi1V1dm+3E7Ai7d/D7P5UK7nTRpIkSZIkSZIm1EhQkGQK8AfgB8DBVXVtkt2ATwGvA34OBJje7azqDRg0BkkCvIa2u+aaqprVHR8Jz5YG9gd2A55dVQY36gs7bSRJkiRJkiRpAvUEL9vSOjtO6AKbZYBDgKOA/6iquUm2ADZKsl9VPdCfiodf9zX/t5G/jwRgPXvA3gLsAHzSwEb9ZGgjSZIkSZIkSf3xMLA0rdsGWofNXcBXewKaVwCvou21uXGiC5ysevYJTQf2pnXYXFJVn+lrYVroGdpIkiRJkiRJ0gRJMqWq5nZ/vR1YDHhmkpWAHYE9gFu6a58DrAb8sapu7EO5C4OVgE2BU4Aj+1yL5E4bSZIkSZIkSRpv3c6U+3rGcY0c/y6wLvAgMKuqXt5zbkfaqLStqurMCSx3oZJkGrB4Vd3b71qkKf0uQJIkSZIkSZImoyRTut+fDxwIfD7JUr3ngMOAW4HntcPZJslaST4L7A+ca2AzvqrqzwY2GhR22kiSJEmSJEnSOEryA2BN4MCq+sY8zq9GC2g2BZbtDj8CHA8cXFW/n6BSJfWZoY0kSZIkSZIkLWAju2uSfBh4L/DBqjq+Oze1quZ0f55eVfd3f34BsAZQwE1V9cu+FC+pbwxtJEmSJEmSJGkcdKPQrgJmAp+qqrt7zi0P7AlsBvwWOB04paoe7kOpkgbEtH4XIEmSJEmSJEmT1Ia0veI/GxXYrA0cCfxvYBawCrAF8CLggxNco6QBMuWJL5EkSZIkSZIkPQWzgBWBvyy5T/IyWmCzAXAI8A/AlsCPgf2SvHHiy5Q0KOy0kSRJkiRJkqTxcUf3631JAG4FjgLWA/YCvlpVDwG/SbIo8GpgRn9KlTQIDG0kSZIkSZIkaRxU1a+THA58AtgUCHAfbb/NlwCSTKmqucBU4G5g8X7VK6n/DG0kSZIkSZIkaZxU1cFJzgL+L/AAcBrwS4Aki1TVI0mmA+vT7tee1bdiJfVdqqrfNUiSJEmSJEnSpJNuJlp1N2GTTK2qOUlSPTdmk2wCHAOcVlXv60+1kgaBoY0kSZIkSZIkjaOeEWjzOrc5sB+wBLDBY10naeEwpd8FSJIkSZIkSdJk9jiBzQuAk4G5wN4GNpLstJEkSZIkSZKkPkmyNnB/VV3X71ok9Z+hjSRJkiRJkiTNpyRLV9XdY/yYv9ptI0mOR5MkSZIkSZKkpyDJ1O739wBHJ5kxj2vyWB9vYCNpNEMbSZIkSZIkSRqjrktmTpJpwKHAfbTdNH9lJJhJ4r1YSU9oWr8LkCRJkiRJkqQhFKCAw4E7gaOraja0UWnAi4Hlgeur6udVNbfrzJlrh42kx2JoI0mSJEmSJElj0HXZzE3yXGA3YB/gqu7cO4H3Auv0XP9vwB5Vde3EVytpmNiSJ0mSJEmSJElj0NMpcxzwe+DiqnqgC3GOBR4A3tr9+hywNnB5kk37Ua+k4RE78SRJkiRJkiRpbJIsB5wDrA+cAhxIC2hmADuMdNUkWQzYnBbwXAD8c1X9ze4bSQJDG0mSJEmSJEkasyRTgJWBtwD7As+gTTbaFjitqirJ1Kqa011/EHAA8Oyq+kOfypY04ByPJkmSJEmSJEljVFVzq+om4HBgI+ArwNXArJHxaVU1pwt3AB4E7gSW60e9koaDnTaSJEmSJEmSNJ+SLAWsUVW/6DmWruNmKeBQ4PXAC6vq/n7VKWmw2WkjSZIkSZIkSfOpqmb3BjbdsZEn5l9LG5t2rIGNpMdjp40kSZIkSZIkjZMkWwMfAR6oqpf1ux5Jg81OG0mSJEmSJEkaB91YtK2Bm4E9+lyOpCFgp40kSZIkSZIkjZMkiwDPqqqb+12LpMFnaCNJkiRJkiRJkjQAHI8mSZIkSZIkSZI0AAxtJEmSJEmSJEmSBoChjSRJkiRJkiRJ0gAwtJEkSZIkSZIkSRoAhjaSJEmSJEmSJEkDwNBGkiRJkiRJkiRpABjaSJIkSZIkSZIkDQBDG0mSJEmaAEmOT3Jjv+uQJEmSNLgMbSRJkiRplCS7J6kkl47x41ZK8vEk6y6gOtbqXm+VBfF6kiRJkgaboY0kSZIk/a3tgBuBDZKsPoaPWwn4GLDuPM7tAjxvjHWs1b3eKmP8OEmSJElDyNBGkiRJknokWRX4R2Af4HZagPNEHzMtyaKPd01VPVJVDy2YKiVJkiRNRoY2kiRJkvTXtgPuAs4CTmFUaJNklW502r5J3pvkOuAhYHfgsu6yb3TXVJJ3dh/3NzttkmyT5PIk9ySZneTKJHt3594JnNxden7P6204Dv/MkiRJkgbAtH4XIEmSJEkDZjvgtKp6OMmJwG5JXlpVl4267l3A4sCxtNDmu8CSwEHdsZ901/1sXp8kycbAicC5wAe7w88HXgEcDlwIHAHsBRwCXN1dczWSJEmSJiVDG0mSJEnqJHkxsCbwnu7QT4FbaEHO6NDm2cDqVXV7z8efQwttLq6qmU/w6TYFZgOvq6o5o09W1fVJfkILbX5UVReM/Z9IkiRJ0jBxPJokSZIkPWo74FbgfICqKuDbwDZJpo669tTewOYpmAU8Ddh4Pl5DkiRJ0iRiaCNJkiRJQBfKbEMLbFZNsnqS1YFLgRWA14z6kBvm81MeBfwGOCfJLUm+nmST+XxNSZIkSUPM0EaSJEmSmlcDK9KCm2t7fn2nO7/dqOsfmJ9PVlW3AesCmwNnAP+HFuD8//l5XUmSJEnDy502kiRJktRsB9wG7DGPc1sC/5zk3U/wGjWWT1hVDwNnAmcmmULrvtk1ySeq6rdjfT1JkiRJw83QRpIkSdJCL8kStGDm5Ko6ZR7n/wBsS+uKufRxXuq+7vcZT+JzLltV/z3y96qam+RX3V8XG+vrSZIkSRp+hjaSJEmS1MKYJWljyublEuB2WjfO44U21wGzgHcnuYcWulxaVfPaf3NckmWA84BbgL8D3gNcAVzdXXMFMAf4YJKlgYeA87rRapIkSZImGXfaSJIkSVILYx4EfjSvk1U1FzgL2ARY9rFepKoeAd5BC1qOBk4EXvUYl8/sPufutLFo7wC+Dby++3xU1Z+AdwPLA1/rXm+tsf2jSZIkSRoWqXJEsiRJkiRJkiRJUr/ZaSNJkiRJkiRJkjQADG0kSZIkSZIkSZIGgKGNJEmSJEmSJEnSADC0kSRJkiRJkiRJGgCGNpIkSZIkSZIkSQPA0EaSJEmSJEmSJGkAGNpIkiRJkiRJkiQNAEMbSZIkSZIkSZKkAWBoI0mSJEmSJEmSNAAMbSRJkiRJkiRJkgaAoY0kSZIkSZIkSdIAMLSRJEmSJEmSJEkaAP8Dl2P5rB8ZcqgAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -854,7 +583,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -873,15 +602,14 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Improvement: 11.132172%\n", - "Improvement: 12.902162%\n" + "Improvement: 13.635495%\n" ] } ], @@ -930,7 +658,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 15, "metadata": { "editable": true, "slideshow": { @@ -944,19 +672,7 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -988,7 +704,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -997,9 +713,6 @@ "text": [ "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", - " warnings.warn(\n", - "WARNING:pydvl.value.semivalues:PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", " warnings.warn(\n" ] } @@ -1037,7 +750,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 17, "metadata": { "editable": true, "slideshow": { @@ -1051,19 +764,7 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1080,7 +781,7 @@ " low_dvl,\n", " title=\"Artists with low data valuation scores\",\n", " xlabel=\"Artist\",\n", - " ylabel=\"Shapley Value\",\n", + " ylabel=\"Banzhaf Value\",\n", ")\n", "ax.get_xticklabels()[low_dvl.index.get_loc(\"Billie Eilish\")].set_color(\"red\")\n", "plt.show()" @@ -1108,7 +809,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1119,22 +820,11 @@ " warnings.warn(\n", " 0%| | 0.0/100 [00:02\n", " \n", " \n", - " blackbear\n", - " -0.990980\n", - " 0.382693\n", - " \n", - " \n", - " CNCO\n", - " -0.985361\n", - " 0.309928\n", - " \n", - " \n", - " Adele\n", - " -0.954124\n", - " 0.429572\n", - " \n", - " \n", - " Ava Max\n", - " -0.803257\n", - " 0.307395\n", + " Liberty X\n", + " -1.143853\n", + " 0.382673\n", " \n", " \n", - " Ariana Grande\n", - " -0.786560\n", - " 0.301802\n", - " \n", - " \n", - "\n", - "" - ], - "text/plain": [ - " data_value data_value_stderr\n", - "blackbear -0.990980 0.382693\n", - "CNCO -0.985361 0.309928\n", - "Adele -0.954124 0.429572\n", - "Ava Max -0.803257 0.307395\n", - "Ariana Grande -0.786560 0.301802" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", "
data_valuedata_value_stderr
BLACKPINK-0.7273400.221131
Kendrick Lamar-0.6051230.227634-1.0671600.442940
CNCO-0.5610160.223759Liam Payne-0.7755980.530834
Zedd-0.5525040.219483Reik-0.7752690.359365
Ariana Grande-0.5518000.215216Alessia Cara-0.7561350.402948
\n", "
" ], "text/plain": [ - " data_value data_value_stderr\n", - "BLACKPINK -0.727340 0.221131\n", - "Kendrick Lamar -0.605123 0.227634\n", - "CNCO -0.561016 0.223759\n", - "Zedd -0.552504 0.219483\n", - "Ariana Grande -0.551800 0.215216" + " data_value data_value_stderr\n", + "Liberty X -1.143853 0.382673\n", + "BLACKPINK -1.067160 0.442940\n", + "Liam Payne -0.775598 0.530834\n", + "Reik -0.775269 0.359365\n", + "Alessia Cara -0.756135 0.402948" ] }, - "execution_count": 40, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1299,24 +921,12 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1333,19 +943,19 @@ " high_dvl,\n", " title=\"Artists with high values\",\n", " xlabel=\"Artist\",\n", - " ylabel=\"MSR Banzhaf value\",\n", + " ylabel=\"Banzhaf Value\",\n", ")\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1354,12 +964,94 @@ "needs_background": "light" }, "output_type": "display_data" - }, + } + ], + "source": [ + "low_dvl = df.iloc[:30]\n", + "ax = plot_shapley(\n", + " low_dvl,\n", + " title=\"Artists with low values\",\n", + " xlabel=\"Artist\",\n", + " ylabel=\"Banzhaf value\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compare convergence speed of Banzhaf and MSR Banzhaf Values\n", + "\n", + "While the conventional Banzhaf values algorithm evaluates the utility twice to do one update of the Banzhaf values, the Maximum Samples Reuse (MSR) algorithm promises higher sample efficiency because it updates multiple samples per one evaluation of the utility. This part of the notebook takes a look at the convergence speed of the algorithms compared with each other." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00" + "
" ] }, "metadata": { @@ -1369,15 +1061,90 @@ } ], "source": [ - "low_dvl = df.iloc[:30]\n", - "ax = plot_shapley(\n", - " low_dvl,\n", - " title=\"Artists with low values\",\n", - " xlabel=\"Artist\",\n", - " ylabel=\"MSR Banzhaf value\",\n", + "# Compare convergence speed of both methods\n", + "import numpy as np\n", + "\n", + "bz_values = history_normal._memory\n", + "msr_values = history_msr._memory\n", + "bz_distances = []\n", + "msr_distances = []\n", + "for iteration in range(num_iterations):\n", + " bz_abs_dist = np.abs(bz_values[:, iteration] - bz_values[:, iteration + 1])\n", + " if bz_abs_dist.max() == 0.0:\n", + " bz_distances.append(0.0)\n", + " else:\n", + " bz_distances.append(np.mean(bz_abs_dist[bz_abs_dist > 0]))\n", + " msr_abs_dist = np.abs(msr_values[:, iteration] - msr_values[:, iteration + 1])\n", + " if msr_abs_dist.max() == 0.0:\n", + " msr_distances.append(0.0)\n", + " else:\n", + " msr_distances.append(np.mean(msr_abs_dist[msr_abs_dist > 0]))\n", + "\n", + "bz_moving_avg = np.convolve(bz_distances, np.ones(200) / 200, mode=\"same\")\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", + "ax.plot(\n", + " list(range(num_iterations)), bz_moving_avg, label=\"MC Banzhaf distance (Moving Avg)\"\n", ")\n", + "ax.plot(list(range(num_iterations)), msr_distances, label=\"MSR Banzhaf distance\")\n", + "ax.set_xlabel(\"Iteration\")\n", + "ax.set_ylabel(\"Mean Semivalue distance between two epochs\")\n", + "ax.set_title(\"Convergence speed of MC Banzhaf vs. MSR Banzhaf\")\n", + "ax.set_ylim([0, 0.3])\n", + "plt.legend()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The plot above visualizes the convergence speed of regular Banzhaf vs Maximum Sample Reuse Banzhaf. It shows the average magnitude of how much the semivalues are updated in every step of the algorithm. As you can see, MSR Banzhaf converges much faster. After 1000 iterations (subsets tried), Monte Carlo Banzhaf has evaluated the marginal function about 5 times per data point. For maximum sample reuse, the semivalue of each data point was updated on average 500 times. Due to this, the values converge much quicker." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████▉| 99.98/100 [00:18<00:00, 5.48%/s] \n", + "100%|█████████▉| 99.97/100 [00:17<00:00, 5.60%/s] \n" + ] + } + ], + "source": [ + "mc_values = compute_banzhaf_semivalues(\n", + " u=utility, sampler_t=UniformSampler, done=MaxChecks(10000), n_jobs=-1, progress=True\n", + ")\n", + "msr_values = compute_msr_banzhaf_semivalues(\n", + " u=utility, done=MaxChecks(10000), n_jobs=-1, progress=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4268817759913272\n", + "SignificanceResult(statistic=0.9189952335500745, pvalue=1.1286299472107335e-74)\n" + ] + } + ], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "print(np.linalg.norm(mc_values.values - msr_values.values))\n", + "print(spearmanr(mc_values.values, msr_values.values))" + ] } ], "metadata": { diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index a93e4a9d3..00c310121 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -313,9 +313,9 @@ def weight(cls, n: int, subset_len: int) -> float: class MSRSampler(StochasticSamplerMixin, PowersetSampler[IndexT]): - """An iterator to perform MSR Monte Carlo sampling of subsets. + """An iterator to perform sampling of random subsets. - This sampler creates random subsets of the data. + This sampler does not return any index, it only returns subsets of the data. This sampler is used in :footcite:t:`wang_data_2022`. """ @@ -324,7 +324,7 @@ def __iter__(self) -> Iterator[SampleT]: return while True: subset = random_subset(self.indices, seed=self._rng) - yield -1, subset + yield None, subset self._n_samples += 1 @classmethod diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 8181cf450..218d90225 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -304,6 +304,8 @@ def compute_generic_semivalues( u: Utility object with model, data, and scoring function. coefficient: The semi-value coefficient done: Stopping criterion. + marginal: Marginal function to be used for computing the semivalues + future_processor: Additional postprocessing steps required for some algorithms batch_size: Number of marginal evaluations per single parallel job. skip_converged: Whether to skip marginal evaluations for indices that have already converged. **CAUTION**: This is only entirely safe if @@ -406,6 +408,10 @@ def compute_generic_semivalues( return result +def always_one_coefficient(n: int, k: int) -> float: + return 1.0 + + def shapley_coefficient(n: int, k: int) -> float: return float(1 / math.comb(n - 1, k) / n) @@ -555,6 +561,13 @@ def compute_msr_banzhaf_semivalues( [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues] with the Banzhaf coefficient and MSR sampling. + This algorithm works by sampling random subsets and then evaluating the utility + on that subset only once. Based on the evaluation and the subset indices, + the MSRFutureProcessor then computes the marginal updates like in the paper + *Data Banzhaf: A Robust Data Valuation Framework for Machine Learning* by Wang et. al. + Their approach updates the semivalues for all data points every time a new evaluation + is computed. This increases sample efficiency compared to normal Monte Carlo updates. + Args: u: Utility object with model, data, and scoring function. done: Stopping criterion. @@ -579,7 +592,7 @@ def compute_msr_banzhaf_semivalues( return compute_generic_semivalues( # type: ignore sampler_t(u.data.indices, seed=seed), u, - lambda n, k: 1.0, # Coefficients not needed + always_one_coefficient, done, marginal=RawUtility(), future_processor=MSRFutureProcessor(u), From bfe5637a48a27d5de07f136b9055047037b9815b Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Wed, 27 Mar 2024 14:58:28 +0100 Subject: [PATCH 10/42] test msr banzhaf methods --- tests/value/test_semivalues.py | 30 +++++++++++------------------- 1 file changed, 11 insertions(+), 19 deletions(-) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 9d1e1dcce..d4e62ed51 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -17,16 +17,15 @@ UniformSampler, ) from pydvl.value.semivalues import ( - MSRMarginal, + DefaultMarginal, SVCoefficient, - _marginal, banzhaf_coefficient, beta_coefficient, compute_generic_semivalues, - msr_banzhaf, + compute_msr_banzhaf_semivalues, shapley_coefficient, ) -from pydvl.value.stopping import HistoryDeviation, MaxUpdates, RankStability +from pydvl.value.stopping import HistoryDeviation, MaxChecks, MaxUpdates from . import check_values from .utils import timed @@ -54,10 +53,12 @@ def test_marginal_batch_size(test_game, sampler, coefficient, batch_size, seed): marginals_single = [] for sample in samples: marginals_single.extend( - _marginal(test_game.u, coefficient=coefficient, samples=[sample]) + DefaultMarginal()(test_game.u, coefficient=coefficient, samples=[sample]) ) - marginals_batch = _marginal(test_game.u, coefficient=coefficient, samples=samples) + marginals_batch = DefaultMarginal()( + test_game.u, coefficient=coefficient, samples=samples + ) assert len(marginals_single) == len(marginals_batch) assert set(marginals_single) == set(marginals_batch) @@ -68,20 +69,11 @@ def test_msr_banzhaf( num_samples: int, analytic_banzhaf, parallel_config, n_jobs, seed: Seed ): u, exact_values = analytic_banzhaf - sampler = MSRSampler() - marginal = MSRMarginal() - values = compute_generic_semivalues( - sampler(u.data.indices, seed=seed), - u=u, - coefficient=coefficient, - marginal=marginal, - criterion=RankStability(rtol=0.1) | MaxUpdates(100), - skip_converged=False, - n_jobs=n_jobs, - config=parallel_config, - progress=True, + values = compute_msr_banzhaf_semivalues( + u=u, done=MaxChecks(1000), config=parallel_config, n_jobs=n_jobs, seed=seed ) - check_values(values, exact_values, rtol=0.1) + # Need to use atol because msr banzhaf is quite noisy. + check_values(values, exact_values, atol=0.1) @pytest.mark.parametrize("n", [10, 100]) From 4542263a1c0045f1f31083895a0f7c78f297aeed Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Wed, 27 Mar 2024 16:59:19 +0100 Subject: [PATCH 11/42] fix batch size update unintentional change --- src/pydvl/value/semivalues.py | 30 ++++++++++++++++++++---------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index a966cfa12..70b83af6f 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -241,7 +241,7 @@ def compute_values(self) -> np.ndarray: def __call__( self, future_result: List[Tuple[List[IndexT], float]] - ) -> Tuple[MarginalT, ...]: + ) -> List[List[MarginalT, ...]]: """Computation of marginal utility using Maximum Sample Reuse. This processor requires the Marginal Function to be set to RawUtility. @@ -259,8 +259,8 @@ def __call__( A collection of marginals. Each marginal is a tuple with index and its marginal utility. """ - marginals: List[MarginalT] = [] - for s, evaluation in future_result: + marginals: List[List[MarginalT]] = [] + for batch_id, (s, evaluation) in enumerate(future_result): previous_values = self.compute_values() self.total_evaluations += 1 self.point_in_subset[s] += 1 @@ -273,9 +273,12 @@ def __call__( self.total_evaluations * new_values - (self.total_evaluations - 1) * previous_values ) + marginals.append([]) for data_index in range(self.n): - marginals.append((data_index, float(marginal_vals[data_index]))) - return tuple(marginals) + marginals[batch_id].append( + (data_index, float(marginal_vals[data_index])) + ) + return marginals # @deprecated( @@ -373,11 +376,18 @@ def compute_generic_semivalues( completed, pending = wait(pending, timeout=1, return_when=FIRST_COMPLETED) for future in completed: - processed_future = future_processor(future.result()) - for idx, marginal_val in processed_future: - result.update(idx, marginal_val) - if done(result): - return result + processed_future = future_processor( + future.result() + ) # List of tuples or + for batch_future in processed_future: + if isinstance(batch_future, list): # Case when batch size is > 1 + for idx, marginal_val in batch_future: + result.update(idx, marginal_val) + else: # Batch size 1 + idx, marginal_val = batch_future + result.update(idx, marginal_val) + if done(result): + return result # Ensure that we always have n_submitted_jobs running try: From 22c5bdb251027ac1c015a49a044370eaed0f5ec7 Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Wed, 27 Mar 2024 17:01:38 +0100 Subject: [PATCH 12/42] update changelog with banzhaf MSR --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index a9cd7bb29..4269f9a04 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - New method: `NystroemSketchInfluence` [PR #504](https://github.com/aai-institute/pyDVL/pull/504) +- New method: `MSR Banzhaf Semivalues` + [PR #504](https://github.com/aai-institute/pyDVL/pull/520) - New preconditioned block variant of conjugate gradient [PR #507](https://github.com/aai-institute/pyDVL/pull/507) - Improvements to documentation: fixes, links, text, example gallery, LFS and From 8f8e1870de6b79c694db8e363a2340d6e3714d23 Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Wed, 27 Mar 2024 17:02:54 +0100 Subject: [PATCH 13/42] update list type hint --- src/pydvl/value/semivalues.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 70b83af6f..c1798da03 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -241,7 +241,7 @@ def compute_values(self) -> np.ndarray: def __call__( self, future_result: List[Tuple[List[IndexT], float]] - ) -> List[List[MarginalT, ...]]: + ) -> List[List[MarginalT]]: """Computation of marginal utility using Maximum Sample Reuse. This processor requires the Marginal Function to be set to RawUtility. From 3a27dfd8f668b04ebd5bc0ce655d767389c5b18b Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Thu, 28 Mar 2024 10:23:07 +0100 Subject: [PATCH 14/42] test additional functionality added --- tests/value/test_sampler.py | 2 ++ tests/value/test_semivalues.py | 29 +++++++++++++++++++++++++++++ tests/value/test_stopping.py | 29 +++++++++++++++++++++++++++++ 3 files changed, 60 insertions(+) diff --git a/tests/value/test_sampler.py b/tests/value/test_sampler.py index 5fbf8f5c0..626078150 100644 --- a/tests/value/test_sampler.py +++ b/tests/value/test_sampler.py @@ -10,6 +10,7 @@ AntitheticSampler, DeterministicPermutationSampler, DeterministicUniformSampler, + MSRSampler, PermutationSampler, RandomHierarchicalSampler, StochasticSampler, @@ -65,6 +66,7 @@ def test_proper_reproducible(sampler_class, indices, seed): PermutationSampler, AntitheticSampler, RandomHierarchicalSampler, + MSRSampler, ], ) @pytest.mark.parametrize("indices", [(), (list(range(100)))]) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index d4e62ed51..f44a1a403 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -18,6 +18,7 @@ ) from pydvl.value.semivalues import ( DefaultMarginal, + MSRFutureProcessor, SVCoefficient, banzhaf_coefficient, beta_coefficient, @@ -276,3 +277,31 @@ def test_banzhaf( config=parallel_config, ) check_values(values, exact_values, rtol=0.2) + + +@pytest.mark.parametrize("num_samples", [6]) +def test_msr_future_processor(num_samples: int, dummy_utility): + proc = MSRFutureProcessor(dummy_utility) + assert proc.n == num_samples + assert proc.total_evaluations == 0 + data1 = [1, 3, 5] + data2 = [0, 2, 4] + + # Iteration 1 + marginals1 = proc([(data1, 1.0)]) + assert marginals1 == [[(i, 0.0) for i in range(6)]] + + # Iteration 2 + marginals2 = proc([(data2, 0.5)]) + assert marginals2 == [ + [(0, -1.0), (1, 1.0), (2, -1.0), (3, 1.0), (4, -1.0), (5, 1.0)] + ] + + # Iteration 3 + # Values are -0.5 for even and 0.5 for uneven indices + # New values are supposed to be -1.0 and 1.0=(1.0+2.0)/2-(0.5)/1 + # Marginals need to be 2 and -2 because (2*0.5 + 1*2)/3=1 + marginals2 = proc([(data1, 2.0)]) + assert marginals2 == [ + [(0, -2.0), (1, 2.0), (2, -2.0), (3, 2.0), (4, -2.0), (5, 2.0)] + ] diff --git a/tests/value/test_stopping.py b/tests/value/test_stopping.py index efebac9c4..f5851c6cf 100644 --- a/tests/value/test_stopping.py +++ b/tests/value/test_stopping.py @@ -13,6 +13,7 @@ MaxTime, MaxUpdates, MinUpdates, + RankStability, StoppingCriterion, make_criterion, ) @@ -196,3 +197,31 @@ def test_max_checks(): for _ in range(4): assert not done(v) assert done(v) + + +def test_rank_stability(): + """Test the RankStability stopping criterion.""" + v = ValuationResult.zeros(indices=range(5)) + arr = np.arange(5) + + done = RankStability(rtol=0.1) + for i in range(20): + arr = np.roll(arr, 1) + for j in range(5): + v.update(j, arr[j] + 0.01 * j) + assert not done(v) + assert not done(v) + assert done(v) + + done = RankStability(rtol=0.1, min_iterations=3) + v = ValuationResult.from_random(size=5) + assert not done(v) + assert not done(v) + assert not done(v) + assert done(v) + + done = RankStability(rtol=0.1, min_iterations=2) + v = ValuationResult.from_random(size=5) + assert not done(v) + assert not done(v) + assert done(v) From ea47b248820c599d947086f629ce15741f64bb8e Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Thu, 28 Mar 2024 10:36:57 +0100 Subject: [PATCH 15/42] update documentation with MSR banzhaf --- docs/value/semi-values.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index 408a90c28..5d71c9ea7 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -98,6 +98,33 @@ values = compute_banzhaf_semivalues( ) ``` +### Banzhaf semi-values with MSR sampling +Wang et. al. propose a more sample-efficient method for computing Banzhaf semivalues in their paper +*Data Banzhaf: A Robust Data Valuation Framework for Machine Learning* [@wang_data_2022]. +This method updates all semivalues per evaluation of the utility (i.e. per model trained) based on whether +a specific data point was included in the data subset or not. +The mathematical formula for computing the semivalues is + +$$\hat{\phi}_{MSR}(i) = \frac{1}{|\mathbf{S}_{\ni i}|} \sum_{S \in \mathbf{S}_{\ni i}} U(S) + - \frac{1}{|\mathbf{S}_{\not{\ni} i}|} \sum_{S \in \mathbf{S}_{\not{\ni} i}} U(S)$$ + +where $\mathbf{S}_{\ni i}$ are the subsets that contain the index $i$ and $\mathbf{S}_{\not{\ni} i}$ are the +subsets not containing the index $i$. + +The function implementing this mehod is +[compute_msr_banzhaf_semivalues][pydvl.value.semivalues.compute_msr_banzhaf_semivalues]. +```python +from pydvl.value import * + +utility = Utility(model, data) +values = compute_msr_banzhaf_semivalues( + u=utility, done=RankStability(rtol=0.001), +) +``` +For further details on how to use this method and a comparison of the sample efficiency, we suggest to take a look +at the example notebook [msr_banzhaf_spotify](../examples/msr_banzhaf_spotify). + + ## General semi-values As explained above, both Beta Shapley and Banzhaf indices are special cases of From 0c83af44894c3e0873253eca33d28671aaab289b Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Thu, 28 Mar 2024 11:02:21 +0100 Subject: [PATCH 16/42] fix documentation links --- docs/value/semi-values.md | 2 +- mkdocs.yml | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index 5d71c9ea7..34be190cf 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -122,7 +122,7 @@ values = compute_msr_banzhaf_semivalues( ) ``` For further details on how to use this method and a comparison of the sample efficiency, we suggest to take a look -at the example notebook [msr_banzhaf_spotify](../examples/msr_banzhaf_spotify). +at the example notebook [msr_banzhaf_spotify](../../examples/msr_banzhaf_spotify). ## General semi-values diff --git a/mkdocs.yml b/mkdocs.yml index 783fb986b..4fe37c39c 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -34,6 +34,7 @@ nav: - Data utility learning: examples/shapley_utility_learning.ipynb - Least Core: examples/least_core_basic.ipynb - Data OOB: examples/data_oob.ipynb + - Banzhaf Semivalues: examples/msr_banzhaf_spotify.ipynb - Influence Function: - For CNNs: examples/influence_imagenet.ipynb - For mislabeled data: examples/influence_synthetic.ipynb From ec343af3ec62fa274805da56ce849f2140ec2760 Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Tue, 2 Apr 2024 08:35:57 +0200 Subject: [PATCH 17/42] disable social plugin in mkdocs to repair ci --- mkdocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/mkdocs.yml b/mkdocs.yml index 4fe37c39c..8222c3a13 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -141,6 +141,7 @@ plugins: type: iso_date fallback_to_build_date: true - social: + enabled: false cards: !ENV [CI, True] # only build in CI theme: From 8ba78c3298109e0137525e5734e8d44a02f39d3a Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Tue, 2 Apr 2024 08:59:35 +0200 Subject: [PATCH 18/42] docs updates from review --- CHANGELOG.md | 2 +- docs/value/semi-values.md | 4 ++-- src/pydvl/value/sampler.py | 5 ++++- src/pydvl/value/semivalues.py | 31 ++++++++++++++++++++++++------- src/pydvl/value/stopping.py | 5 ++++- 5 files changed, 35 insertions(+), 12 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4269f9a04..5de43f321 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,7 +7,7 @@ - New method: `NystroemSketchInfluence` [PR #504](https://github.com/aai-institute/pyDVL/pull/504) - New method: `MSR Banzhaf Semivalues` - [PR #504](https://github.com/aai-institute/pyDVL/pull/520) + [PR #520](https://github.com/aai-institute/pyDVL/pull/520) - New preconditioned block variant of conjugate gradient [PR #507](https://github.com/aai-institute/pyDVL/pull/507) - Improvements to documentation: fixes, links, text, example gallery, LFS and diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index 34be190cf..1d6254342 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -111,10 +111,10 @@ $$\hat{\phi}_{MSR}(i) = \frac{1}{|\mathbf{S}_{\ni i}|} \sum_{S \in \mathbf{S}_{\ where $\mathbf{S}_{\ni i}$ are the subsets that contain the index $i$ and $\mathbf{S}_{\not{\ni} i}$ are the subsets not containing the index $i$. -The function implementing this mehod is +The function implementing this method is [compute_msr_banzhaf_semivalues][pydvl.value.semivalues.compute_msr_banzhaf_semivalues]. ```python -from pydvl.value import * +from pydvl.value import compute_msr_banzhaf_semivalues, RankStability, Utility utility = Utility(model, data) values = compute_msr_banzhaf_semivalues( diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 72b2304d2..811c4caf8 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -44,6 +44,9 @@ Frank, and Geoffrey Holmes. [Sampling Permutations for Shapley Value Estimation](http://jmlr.org/papers/v23/21-0439.html). Journal of Machine Learning Research 23, no. 43 (2022): 1–46. +[^2]: Wang, J.T. and Jia, R., 2023. + [Data Banzhaf: A Robust Data Valuation Framework for Machine Learning](https://proceedings.mlr.press/v206/wang23e.html). + In: Proceedings of The 26th International Conference on Artificial Intelligence and Statistics, pp. 6388-6421. """ @@ -316,7 +319,7 @@ class MSRSampler(StochasticSamplerMixin, PowersetSampler[IndexT]): """An iterator to perform sampling of random subsets. This sampler does not return any index, it only returns subsets of the data. - This sampler is used in :footcite:t:`wang_data_2022`. + This sampler is used in (Wang et. al.)2. """ def __iter__(self) -> Iterator[SampleT]: diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index c1798da03..c78a89220 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -81,9 +81,9 @@ [Beta Shapley: A Unified and Noise-reduced Data Valuation Framework for Machine Learning](https://arxiv.org/abs/2110.14049). In: Proceedings of the 25th International Conference on Artificial Intelligence and Statistics (AISTATS) 2022, Vol. 151. PMLR, Valencia, Spain. -[^3]: Wang, J.T. and Jia, R., 2022. - [Data Banzhaf: A Robust Data Valuation Framework for Machine Learning](https://arxiv.org/abs/2205.15466). - ArXiv preprint arXiv:2205.15466. +[^3]: Wang, J.T. and Jia, R., 2023. + [Data Banzhaf: A Robust Data Valuation Framework for Machine Learning](https://proceedings.mlr.press/v206/wang23e.html). + In: Proceedings of The 26th International Conference on Artificial Intelligence and Statistics, pp. 6388-6421. """ from __future__ import annotations @@ -183,7 +183,7 @@ class RawUtility(MarginalFunction): def __call__( self, u: Utility, coefficient: SVCoefficient, samples: Iterable[SampleT] ) -> Tuple[MarginalT, ...]: - """Computation of marginal utility. This is a helper function for + """Computation of raw utility without marginalization. This is a helper function for [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues]. Args: @@ -193,8 +193,7 @@ def __call__( indices to compute a marginal utility. Returns: - A collection of marginals. Each marginal is a tuple with index and its marginal - utility. + A collection of marginals. Each marginal is a tuple with index and its raw utility. """ marginals: List[MarginalT] = [] for idx, s in samples: @@ -203,11 +202,29 @@ def __call__( class FutureProcessor: + """ + The FutureProcessor class used to process the results of the parallel marginal evaluations. + + The marginals are evaluated in parallel by `n_jobs` threads, but some algorithms require a central + method to postprocess the marginal results. This can be achieved through the future processor. + This base class does not perform any postprocessing, it is a noop used in most data valuation algorithms. + """ + def __call__(self, future_result: Any) -> Any: return future_result class MSRFutureProcessor(FutureProcessor): + """ + This FutureProcessor processes the raw marginals in a way that MSR sampling requires. + + MSR sampling evaluates the utility once, and then updates all data semivalues based on this one evaluation. + In order to do this, the RawUtility value needs to be postprocessed through this class. + For more details on MSR, please refer to the paper (Wang et. al.)3. + This processor keeps track of the current values and computes marginals for all data points, so that + the values in the ValuationResult can be updated properly down the line. + """ + def __init__(self, u: Utility): self.n = len(u.data) self.all_indices = u.data.indices.copy() @@ -574,7 +591,7 @@ def compute_msr_banzhaf_semivalues( This algorithm works by sampling random subsets and then evaluating the utility on that subset only once. Based on the evaluation and the subset indices, the MSRFutureProcessor then computes the marginal updates like in the paper - *Data Banzhaf: A Robust Data Valuation Framework for Machine Learning* by Wang et. al. + (Wang et. al.)3. Their approach updates the semivalues for all data points every time a new evaluation is computed. This increases sample efficiency compared to normal Monte Carlo updates. diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 6568f5e2f..dae984a28 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -115,6 +115,9 @@ [^1]: Ghorbani, A., Zou, J., 2019. [Data Shapley: Equitable Valuation of Data for Machine Learning](https://proceedings.mlr.press/v97/ghorbani19c.html). In: Proceedings of the 36th International Conference on Machine Learning, PMLR, pp. 2242–2251. +[^2]: Wang, J.T. and Jia, R., 2023. + [Data Banzhaf: A Robust Data Valuation Framework for Machine Learning](https://proceedings.mlr.press/v206/wang23e.html). + In: Proceedings of The 26th International Conference on Artificial Intelligence and Statistics, pp. 6388-6421. """ from __future__ import annotations @@ -637,7 +640,7 @@ class RankStability(StoppingCriterion): This means it focuses on the order of the elements instead of their exact values. If the order stops changing (meaning the Banzhaf semivalues estimates converge), the criterion stops the algorithm. - This criterion is used in :footcite:t:`wang_data_2022`. + This criterion is used in (Wang et. al.)2. Args: rtol: Relative tolerance for convergence ($\epsilon$ in the formula) From c2adbdc7edcb6d04d638ca9925c0285887f625f4 Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Tue, 2 Apr 2024 09:09:22 +0200 Subject: [PATCH 19/42] check order of elements in test --- tests/value/test_semivalues.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index f44a1a403..04f108398 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -71,11 +71,18 @@ def test_msr_banzhaf( ): u, exact_values = analytic_banzhaf values = compute_msr_banzhaf_semivalues( - u=u, done=MaxChecks(1000), config=parallel_config, n_jobs=n_jobs, seed=seed + u=u, + done=MaxChecks(200 * num_samples), + config=parallel_config, + n_jobs=n_jobs, + seed=seed, ) # Need to use atol because msr banzhaf is quite noisy. check_values(values, exact_values, atol=0.1) + # Check order + assert np.array_equal(np.argsort(exact_values), np.argsort(values)) + @pytest.mark.parametrize("n", [10, 100]) @pytest.mark.parametrize( From 57aa3354a41a359358f49d1ac9256abb7467ef6c Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Wed, 3 Apr 2024 09:47:18 +0200 Subject: [PATCH 20/42] rename bibliography entry for wang_data_2023 --- docs/assets/pydvl.bib | 2 +- docs/value/semi-values.md | 31 +++++++++++++++++-------------- src/pydvl/value/sampler.py | 4 ++-- src/pydvl/value/semivalues.py | 8 ++++---- src/pydvl/value/stopping.py | 4 ++-- 5 files changed, 26 insertions(+), 23 deletions(-) diff --git a/docs/assets/pydvl.bib b/docs/assets/pydvl.bib index e5b1571e6..724e75f20 100644 --- a/docs/assets/pydvl.bib +++ b/docs/assets/pydvl.bib @@ -450,7 +450,7 @@ @book{trefethen_numerical_1997 langid = {english} } -@inproceedings{wang_data_2022, +@inproceedings{wang_data_2023, title = {Data {{Banzhaf}}: {{A Robust Data Valuation Framework}} for {{Machine Learning}}}, shorttitle = {Data {{Banzhaf}}}, booktitle = {Proceedings of {{The}} 26th {{International Conference}} on {{Artificial Intelligence}} and {{Statistics}}}, diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index 1d6254342..2dabc0dfb 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -21,7 +21,7 @@ the set $D_{-i}^{(k)}$ contains all subsets of $D$ of size $k$ that do not include sample $x_i$, $S_{+i}$ is the set $S$ with $x_i$ added, and $u$ is the utility function. -Two instances of this are **Banzhaf indices** [@wang_data_2022], +Two instances of this are **Banzhaf indices** [@wang_data_2023], and **Beta Shapley** [@kwon_beta_2022], with better numerical and rank stability in certain situations. @@ -84,7 +84,7 @@ any choice of weight function $w$, one can always construct a utility with higher variance where $w$ is greater. Therefore, in a worst-case sense, the best one can do is to pick a constant weight. -The authors of [@wang_data_2022] show that Banzhaf indices are more robust to +The authors of [@wang_data_2023] show that Banzhaf indices are more robust to variance in the utility function than Shapley and Beta Shapley values. They are available in pyDVL through [compute_banzhaf_semivalues][pydvl.value.semivalues.compute_banzhaf_semivalues]: @@ -99,17 +99,19 @@ values = compute_banzhaf_semivalues( ``` ### Banzhaf semi-values with MSR sampling -Wang et. al. propose a more sample-efficient method for computing Banzhaf semivalues in their paper -*Data Banzhaf: A Robust Data Valuation Framework for Machine Learning* [@wang_data_2022]. -This method updates all semivalues per evaluation of the utility (i.e. per model trained) based on whether -a specific data point was included in the data subset or not. -The mathematical formula for computing the semivalues is +Wang et. al. propose a more sample-efficient method for computing Banzhaf +semivalues in their paper *Data Banzhaf: A Robust Data Valuation Framework +for Machine Learning* [@wang_data_2023]. This method updates all semivalues +per evaluation of the utility (i.e. per model trained) based on whether a +specific data point was included in the data subset or not. The expression +for computing the semivalues is -$$\hat{\phi}_{MSR}(i) = \frac{1}{|\mathbf{S}_{\ni i}|} \sum_{S \in \mathbf{S}_{\ni i}} U(S) - - \frac{1}{|\mathbf{S}_{\not{\ni} i}|} \sum_{S \in \mathbf{S}_{\not{\ni} i}} U(S)$$ +$$\hat{\phi}_{MSR}(i) = \frac{1}{|\mathbf{S}_{\ni i}|} \sum_{S \in +\mathbf{S}_{\ni i}} U(S) - \frac{1}{|\mathbf{S}_{\not{\ni} i}|} +\sum_{S \in \mathbf{S}_{\not{\ni} i}} U(S)$$ -where $\mathbf{S}_{\ni i}$ are the subsets that contain the index $i$ and $\mathbf{S}_{\not{\ni} i}$ are the -subsets not containing the index $i$. +where $\mathbf{S}_{\ni i}$ are the subsets that contain the index $i$ and +$\mathbf{S}_{\not{\ni} i}$ are the subsets not containing the index $i$. The function implementing this method is [compute_msr_banzhaf_semivalues][pydvl.value.semivalues.compute_msr_banzhaf_semivalues]. @@ -121,8 +123,9 @@ values = compute_msr_banzhaf_semivalues( u=utility, done=RankStability(rtol=0.001), ) ``` -For further details on how to use this method and a comparison of the sample efficiency, we suggest to take a look -at the example notebook [msr_banzhaf_spotify](../../examples/msr_banzhaf_spotify). +For further details on how to use this method and a comparison of the sample +efficiency, we suggest to take a look at the example notebook +[msr_banzhaf_spotify](../../examples/msr_banzhaf_spotify). ## General semi-values @@ -157,7 +160,7 @@ values = compute_generic_semivalues( Allowing any coefficient can help when experimenting with models which are more sensitive to changes in training set size. However, Data Banzhaf indices are proven to be the most robust to variance in the utility function, in the sense -of rank stability, across a range of models and datasets [@wang_data_2022]. +of rank stability, across a range of models and datasets [@wang_data_2023]. !!! warning "Careful with permutation sampling" This generic implementation of semi-values allowing for any combination of diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 811c4caf8..2fc186813 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -44,7 +44,7 @@ Frank, and Geoffrey Holmes. [Sampling Permutations for Shapley Value Estimation](http://jmlr.org/papers/v23/21-0439.html). Journal of Machine Learning Research 23, no. 43 (2022): 1–46. -[^2]: Wang, J.T. and Jia, R., 2023. +[^2]: Wang, J.T. and Jia, R., 2023. [Data Banzhaf: A Robust Data Valuation Framework for Machine Learning](https://proceedings.mlr.press/v206/wang23e.html). In: Proceedings of The 26th International Conference on Artificial Intelligence and Statistics, pp. 6388-6421. @@ -319,7 +319,7 @@ class MSRSampler(StochasticSamplerMixin, PowersetSampler[IndexT]): """An iterator to perform sampling of random subsets. This sampler does not return any index, it only returns subsets of the data. - This sampler is used in (Wang et. al.)2. + This sampler is used in (Wang et. al.)2. """ def __iter__(self) -> Iterator[SampleT]: diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index c78a89220..d09fd7b07 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -81,7 +81,7 @@ [Beta Shapley: A Unified and Noise-reduced Data Valuation Framework for Machine Learning](https://arxiv.org/abs/2110.14049). In: Proceedings of the 25th International Conference on Artificial Intelligence and Statistics (AISTATS) 2022, Vol. 151. PMLR, Valencia, Spain. -[^3]: Wang, J.T. and Jia, R., 2023. +[^3]: Wang, J.T. and Jia, R., 2023. [Data Banzhaf: A Robust Data Valuation Framework for Machine Learning](https://proceedings.mlr.press/v206/wang23e.html). In: Proceedings of The 26th International Conference on Artificial Intelligence and Statistics, pp. 6388-6421. """ @@ -220,7 +220,7 @@ class MSRFutureProcessor(FutureProcessor): MSR sampling evaluates the utility once, and then updates all data semivalues based on this one evaluation. In order to do this, the RawUtility value needs to be postprocessed through this class. - For more details on MSR, please refer to the paper (Wang et. al.)3. + For more details on MSR, please refer to the paper (Wang et. al.)3. This processor keeps track of the current values and computes marginals for all data points, so that the values in the ValuationResult can be updated properly down the line. """ @@ -591,7 +591,7 @@ def compute_msr_banzhaf_semivalues( This algorithm works by sampling random subsets and then evaluating the utility on that subset only once. Based on the evaluation and the subset indices, the MSRFutureProcessor then computes the marginal updates like in the paper - (Wang et. al.)3. + (Wang et. al.)3. Their approach updates the semivalues for all data points every time a new evaluation is computed. This increases sample efficiency compared to normal Monte Carlo updates. @@ -736,7 +736,7 @@ def compute_semivalues( parameters of the Beta distribution (both default to 1). - [SemiValueMode.Banzhaf][pydvl.value.semivalues.SemiValueMode]: Implements the Banzhaf semi-value as introduced in (Wang and Jia, 2022)1. + href="#wang_data_2023">1. See [Data valuation][data-valuation] for an overview of valuation. diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index dae984a28..06962d67b 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -115,7 +115,7 @@ [^1]: Ghorbani, A., Zou, J., 2019. [Data Shapley: Equitable Valuation of Data for Machine Learning](https://proceedings.mlr.press/v97/ghorbani19c.html). In: Proceedings of the 36th International Conference on Machine Learning, PMLR, pp. 2242–2251. -[^2]: Wang, J.T. and Jia, R., 2023. +[^2]: Wang, J.T. and Jia, R., 2023. [Data Banzhaf: A Robust Data Valuation Framework for Machine Learning](https://proceedings.mlr.press/v206/wang23e.html). In: Proceedings of The 26th International Conference on Artificial Intelligence and Statistics, pp. 6388-6421. """ @@ -640,7 +640,7 @@ class RankStability(StoppingCriterion): This means it focuses on the order of the elements instead of their exact values. If the order stops changing (meaning the Banzhaf semivalues estimates converge), the criterion stops the algorithm. - This criterion is used in (Wang et. al.)2. + This criterion is used in (Wang et. al.)2. Args: rtol: Relative tolerance for convergence ($\epsilon$ in the formula) From 737c0d348a703dd7aebb9e19068d7373046034ec Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Wed, 3 Apr 2024 10:57:20 +0200 Subject: [PATCH 21/42] minor changes in stopping formatting --- src/pydvl/value/stopping.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 06962d67b..b3d1fdb13 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -636,9 +636,10 @@ class RankStability(StoppingCriterion): When the change in rank correlation between two successive iterations is below a given threshold, the computation is terminated. The criterion computes the Spearman correlation between two successive iterations. - The Spearman correlation uses the ordering indices of the given values and correlates them. - This means it focuses on the order of the elements instead of their exact values. - If the order stops changing (meaning the Banzhaf semivalues estimates converge), the criterion stops the algorithm. + The Spearman correlation uses the ordering indices of the given values and + correlates them. This means it focuses on the order of the elements instead of their + exact values. If the order stops changing (meaning the Banzhaf semivalues estimates + converge), the criterion stops the algorithm. This criterion is used in (Wang et. al.)2. @@ -647,7 +648,10 @@ class RankStability(StoppingCriterion): """ def __init__( - self, rtol: float, modify_result: bool = True, min_iterations: int = 10 + self, + rtol: float, + modify_result: bool = True, + min_iterations: int = 10, ): super().__init__(modify_result=modify_result) if rtol <= 0 or rtol >= 1: @@ -678,7 +682,7 @@ def _check(self, r: ValuationResult) -> Status: f"RankStability has converged with {corr=} in iteration {self._iterations}" ) return Status.Converged - self._corr = np.nan_to_num(corr, 0.0) + self._corr = np.nan_to_num(corr, nan=0.0) return Status.Pending def _update_completion(self, corr: float) -> None: From ac2a71df9bde90b9a407e77dab9e929c2dc0b89e Mon Sep 17 00:00:00 2001 From: Jakob Kruse Date: Thu, 4 Apr 2024 14:02:56 +0200 Subject: [PATCH 22/42] rewrite banzhaf notebook --- mkdocs.yml | 2 +- notebooks/msr_banzhaf_digits.ipynb | 807 ++++++++++++++++++ notebooks/msr_banzhaf_spotify.ipynb | 1177 --------------------------- notebooks/support/banzhaf.py | 42 + 4 files changed, 850 insertions(+), 1178 deletions(-) create mode 100644 notebooks/msr_banzhaf_digits.ipynb delete mode 100644 notebooks/msr_banzhaf_spotify.ipynb create mode 100644 notebooks/support/banzhaf.py diff --git a/mkdocs.yml b/mkdocs.yml index b6b3affd9..f9f74530e 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -34,7 +34,7 @@ nav: - Data utility learning: examples/shapley_utility_learning.ipynb - Least Core: examples/least_core_basic.ipynb - Data OOB: examples/data_oob.ipynb - - Banzhaf Semivalues: examples/msr_banzhaf_spotify.ipynb + - Banzhaf Semivalues: examples/msr_banzhaf_digits.ipynb - Influence Function: - For CNNs: examples/influence_imagenet.ipynb - For mislabeled data: examples/influence_synthetic.ipynb diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb new file mode 100644 index 000000000..697afeb34 --- /dev/null +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -0,0 +1,807 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Banzhaf Values for data valuation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similar to the Shapley values notebook, this notebook shows how to compute Banzhaf values using pyDVL.\n", + "Banzhaf semivalues achieve a higher safety margin when compared with other methods like Shapley or LOO semivalues.\n", + "\n", + "This notebook compares two sampling techniques for computing Banzhaf semivalues, a simple Monte Carlo sampling technique\n", + "and another sampling technique using the MSR (Maximum Sample Reuse) principle. We also compare both techniques in this notebook.\n", + "\n", + "In this notebook, we will use a CNN to classify handwritten digits from the [scikit-learn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html#optical-recognition-of-handwritten-digits-dataset)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "We begin by importing the main libraries and setting some defaults.\n", + "\n", + "
\n", + "\n", + "If you are reading this in the documentation, some boilerplate (including most plotting code) has been omitted for convenience.\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "%load_ext autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "%autoreload\n", + "%matplotlib inline\n", + "\n", + "import os\n", + "import random\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "plt.ioff() # Prevent jupyter from automatically plotting\n", + "plt.rcParams[\"figure.figsize\"] = (20, 6)\n", + "plt.rcParams[\"font.size\"] = 12\n", + "plt.rcParams[\"xtick.labelsize\"] = 12\n", + "plt.rcParams[\"ytick.labelsize\"] = 10\n", + "plt.rcParams[\"axes.facecolor\"] = (1, 1, 1, 0)\n", + "plt.rcParams[\"figure.facecolor\"] = (1, 1, 1, 0)\n", + "\n", + "is_CI = os.environ.get(\"CI\")\n", + "random_state = 24\n", + "random.seed(random_state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will be using the following functions from pyDVL. The main entry point is the function `compute_banzhaf_semivalues()`.\n", + "In order to use it we need the classes [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset), [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility) and [Scorer](../../api/pydvl/utils/score/#pydvl.utils.score.Scorer)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%autoreload\n", + "from pydvl.reporting.plots import plot_shapley\n", + "from support.banzhaf import load_digits_dataset\n", + "from pydvl.value import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading and grouping the dataset\n", + "\n", + "pyDVL provides a support function for this notebook, `load_digits_dataset()`, which downloads the data and prepares it for usage. The data consists of greyscale images of shape 8x8 pixels with 16 shades of grey. These images contain handwritten digits from 0 to 9." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "training_data, _, test_data = load_digits_dataset(\n", + " test_size=0.3, random_state=random_state\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "# In CI we only use a subset of the training set\n", + "training_data = list(training_data)\n", + "if is_CI:\n", + " training_data[0] = training_data[0][:10]\n", + " training_data[1] = training_data[1][:10]\n", + " max_checks = 10\n", + "else:\n", + " training_data[0] = training_data[0][:200]\n", + " training_data[1] = training_data[1][:200]\n", + " max_checks = 1000" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Visualize some of the data\n", + "fig, axes = plt.subplots(2, 2, figsize=(4, 4))\n", + "for i in range(4):\n", + " ax = axes[i % 2, i // 2]\n", + " ax.imshow(np.reshape(training_data[0][i], (8, 8)), cmap=\"grey\")\n", + " ax.set_xlabel(f\"Label: {training_data[1][i]}\")\n", + "plt.suptitle(\"Example images from the dataset\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Training and test data are then used to instantiate a [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset) object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = Dataset(*training_data, *test_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating the utility and computing Banzhaf semivalues\n", + "\n", + "Now we can calculate the contribution of each group to the model performance.\n", + "\n", + "As a model, we use scikit-learn's [GradientBoostingRegressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html), but pyDVL can work with any model from sklearn, xgboost or lightgbm. More precisely, any model that implements the protocol [pydvl.utils.types.SupervisedModel](../../api/pydvl/utils/types/#pydvl.utils.types.SupervisedModel), which is just the standard sklearn interface of `fit()`,`predict()` and `score()` can be used to construct the utility.\n", + "\n", + "The third and final component is the scoring function. It can be anything like accuracy or $R^2$, and is set with a string from the [standard sklearn scoring methods](https://scikit-learn.org/stable/modules/model_evaluation.html). Please refer to that documentation on information on how to define your own scoring function.\n", + "\n", + "We group dataset, model and scoring function into an instance of [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch import nn, optim\n", + "from torch.utils.data import TensorDataset, DataLoader\n", + "from numpy.typing import NDArray\n", + "from pydvl.utils.types import SupervisedModel\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "\n", + "class TorchCNNModel(SupervisedModel):\n", + " def __init__(self, lr=0.001, epochs=40, batch_size=32):\n", + " self.lr = lr\n", + " self.batch_size = batch_size\n", + " self.model = nn.Sequential(\n", + " nn.Conv2d(\n", + " out_channels=8, in_channels=1, kernel_size=(3, 3), padding=\"same\"\n", + " ),\n", + " nn.Conv2d(\n", + " out_channels=4, in_channels=8, kernel_size=(3, 3), padding=\"same\"\n", + " ),\n", + " nn.MaxPool2d(kernel_size=2),\n", + " nn.Flatten(),\n", + " nn.Linear(in_features=64, out_features=32),\n", + " nn.Linear(in_features=32, out_features=10),\n", + " nn.Softmax(dim=1),\n", + " )\n", + " self.loss = nn.CrossEntropyLoss()\n", + " self.optimizer = optim.Adam(self.model.parameters(), lr=lr)\n", + " self.epochs = epochs\n", + " self.model.to(device)\n", + "\n", + " def fit(self, x: NDArray, y: NDArray) -> None:\n", + " torch_dataset = TensorDataset(\n", + " torch.tensor(\n", + " np.reshape(x, (x.shape[0], 1, 8, 8)), dtype=torch.float, device=device\n", + " ),\n", + " torch.tensor(y, device=device),\n", + " )\n", + " torch_dataloader = DataLoader(torch_dataset, batch_size=self.batch_size)\n", + " for epoch in range(self.epochs):\n", + " for features, labels in torch_dataloader:\n", + " pred = self.model(features)\n", + " loss = self.loss(pred, labels)\n", + " loss.backward()\n", + " self.optimizer.step()\n", + "\n", + " def predict(self, x: NDArray) -> NDArray:\n", + " pred = self.model(\n", + " torch.tensor(\n", + " np.reshape(x, (x.shape[0], 1, 8, 8)), dtype=torch.float, device=device\n", + " )\n", + " )\n", + " pred = torch.argmax(pred, dim=1)\n", + " return pred.numpy()\n", + "\n", + " def score(self, x: NDArray, y: NDArray) -> float:\n", + " pred = self.predict(x)\n", + " acc = accuracy_score(pred, y)\n", + " return acc\n", + "\n", + " def get_params(self, deep: bool = False):\n", + " return {\"lr\": self.lr, \"epochs\": self.epochs}\n", + "\n", + "\n", + "model = TorchCNNModel(lr=0.001, epochs=40)\n", + "model.fit(x=training_data[0], y=training_data[1])\n", + "print(f\"Train Accuracy: {model.score(x=training_data[0], y=training_data[1]):.3f}\")\n", + "print(f\"Test Accuracy: {model.score(x=test_data[0], y=test_data[1]):.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute regular Banzhaf semivalue\n", + "utility = Utility(\n", + " model=TorchCNNModel(),\n", + " data=dataset,\n", + " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", + ")\n", + "values = compute_banzhaf_semivalues(\n", + " utility, done=MaxChecks(max_checks), n_jobs=-1, progress=True\n", + ")\n", + "values.sort(key=\"value\")\n", + "df = values.to_dataframe(column=\"data_value\", use_names=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's take a look at the returned dataframe:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us plot the results. In the next cell we will take the 30 images with the lowest score and plot their values with 95% Normal confidence intervals. Keep in mind that Monte Carlo Banzhaf is typically very noisy, and it can take many steps to arrive at a clean estimate." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input", + "invertible-output" + ] + }, + "outputs": [], + "source": [ + "low_dvl = df.iloc[:30].copy()\n", + "low_dvl.index = low_dvl.index.map(str)\n", + "plot_shapley(\n", + " low_dvl,\n", + " level=0.05,\n", + " title=\"Images with low values\",\n", + " xlabel=\"Image\",\n", + " ylabel=\"Banzhaf value\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluation on anomalous data\n", + "\n", + "An interesting usecase for data valuation is finding anomalous data. Maybe some of the data is really noisy or has been mislabeled. To simulate this, we will change some of the labels of our dataset and add noise to some others. Intuitively, these anomalous data points should then have a lower value.\n", + "\n", + "To evaluate this, let us first check the average value of the first 10 data points, as these will be the ones that we modify. Currently, these are the 10 data points with the highest semivalues:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input", + "invertible-output" + ] + }, + "outputs": [], + "source": [ + "high_dvl = df.iloc[-10:].copy()\n", + "print(f\"Average value of first 10 data points: {high_dvl['data_value'].mean()}\")\n", + "print(f\"Exact values:\\n{high_dvl['data_value']}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the first 5 images, we will falsify their label, for images 6-10, we will add some noise." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x_train_anomalous = training_data[0].copy()\n", + "y_train_anomalous = training_data[1].copy()\n", + "anomalous_indices = high_dvl.index.map(int).values[:10]\n", + "\n", + "# Set label of first 5 images to 0\n", + "y_train_anomalous[high_dvl.index.map(int).values[:5]] = 0\n", + "\n", + "# Add noise to images 6-10\n", + "indices = high_dvl.index.values[5:10].astype(int)\n", + "current_images = x_train_anomalous[indices]\n", + "noisy_images = current_images + 0.5 * np.random.randn(*current_images.shape)\n", + "noisy_images[noisy_images < 0] = 0.0\n", + "noisy_images[noisy_images > 1] = 1.0\n", + "x_train_anomalous[indices] = noisy_images\n", + "\n", + "fig, axes = plt.subplots(2, 5, figsize=(9, 5))\n", + "for i in range(5):\n", + " axes[0, i].imshow(np.reshape(current_images[i], (8, 8)), cmap=\"grey\")\n", + " axes[1, i].imshow(np.reshape(noisy_images[i], (8, 8)), cmap=\"grey\")\n", + " axes[0, i].set_xlabel(f\"Original: {training_data[1][indices[i]]}\")\n", + " axes[1, i].set_xlabel(f\"Noisy: {training_data[1][indices[i]]}\")\n", + "plt.suptitle(\"Original and noisy versions of images 6-10\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "anomalous_dataset = Dataset(\n", + " x_train=x_train_anomalous,\n", + " y_train=y_train_anomalous,\n", + " x_test=test_data[0],\n", + " y_test=test_data[1],\n", + ")\n", + "\n", + "anomalous_utility = Utility(\n", + " model=TorchCNNModel(),\n", + " data=anomalous_dataset,\n", + " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", + ")\n", + "anomalous_values = compute_banzhaf_semivalues(\n", + " anomalous_utility, done=MaxChecks(max_checks), n_jobs=-1, progress=True\n", + ")\n", + "anomalous_values.sort(key=\"value\")\n", + "anomalous_df = anomalous_values.to_dataframe(column=\"data_value\", use_names=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us now take a look at the low-value images and check how many of our anomalous images are part of it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input", + "invertible-output" + ] + }, + "outputs": [], + "source": [ + "from scipy.stats import norm\n", + "\n", + "\n", + "plot_data = anomalous_df.loc[anomalous_indices].copy()\n", + "plot_data[\"original_data_value\"] = df.loc[anomalous_indices][\"data_value\"]\n", + "plot_data[\"original_data_value_stderr\"] = df.loc[anomalous_indices][\"data_value_stderr\"]\n", + "plot_data.index = plot_data.index.map(str)\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", + "yerr = norm.ppf(1 - 0.05 / 2) * plot_data[\"data_value_stderr\"]\n", + "original_yerr = norm.ppf(1 - 0.05 / 2) * plot_data[\"original_data_value_stderr\"]\n", + "ax.errorbar(\n", + " x=plot_data.index,\n", + " y=plot_data[\"data_value\"],\n", + " yerr=yerr,\n", + " fmt=\"o\",\n", + " capsize=6,\n", + " color=\"red\",\n", + " label=\"Anomalous\",\n", + ")\n", + "ax.errorbar(\n", + " x=plot_data.index,\n", + " y=plot_data[\"original_data_value\"],\n", + " yerr=original_yerr,\n", + " fmt=\"o\",\n", + " capsize=6,\n", + " color=\"green\",\n", + " label=\"Original\",\n", + ")\n", + "ax.set_xlabel(\"Image\")\n", + "ax.set_ylabel(\"Banzhaf Value\")\n", + "ax.set_title(\"Data valuation scores of anomalous images\")\n", + "plt.legend()\n", + "plt.xticks(rotation=60)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As can be seen in this figure, the valuation of the data points has decreased significantly by adding noise or falsifying their labels.\n", + "This shows the potential of using Banzhaf values or other data valuation methods to detect mislabeled data points or noisy input data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\n", + " f\"Average value of original data points: {plot_data['original_data_value'].mean()}\"\n", + ")\n", + "print(\n", + " f\"Average value of modified, anomalous data points: {plot_data['data_value'].mean()}\"\n", + ")\n", + "print(\n", + " \"For reference, these are the average data values of all data points used for training (anomalous):\"\n", + ")\n", + "print(anomalous_df.mean())\n", + "print(\"These are the average data values of all points (original data):\")\n", + "print(df.mean())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Maximum Sample Reuse Banzhaf\n", + "\n", + "Now, we want to use a method called Maximum Sample Reuse (MSR) which reuses samples for updating the Banzhaf values.\n", + "The method is introduced by Wang et al. in the paper *Data Banzhaf: A Robust Data Valuation Framework for Machine Learning*.\n", + "It promises a higher sample efficiency by using a principle called Maximum Sample Reuse for sampling and updating semivalues." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute MSR Banzhaf semivalue\n", + "utility = Utility(\n", + " model=TorchCNNModel(),\n", + " data=dataset,\n", + " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", + ")\n", + "values = compute_msr_banzhaf_semivalues(\n", + " utility,\n", + " done=RankStability(0.0001),\n", + " n_jobs=-1,\n", + " progress=True,\n", + ")\n", + "values.sort(key=\"value\")\n", + "msr_df = values.to_dataframe(column=\"data_value\", use_names=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "msr_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "high_dvl = df.iloc[-30:]\n", + "high_dvl.index = high_dvl.index.map(str)\n", + "ax = plot_shapley(\n", + " high_dvl,\n", + " title=\"Images with high values\",\n", + " xlabel=\"Image\",\n", + " ylabel=\"Banzhaf Value\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "low_dvl = df.iloc[:30]\n", + "low_dvl.index = low_dvl.index.map(str)\n", + "ax = plot_shapley(\n", + " low_dvl,\n", + " title=\"Images with low values\",\n", + " xlabel=\"Image\",\n", + " ylabel=\"Banzhaf value\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compare convergence speed of Banzhaf and MSR Banzhaf Values\n", + "\n", + "While the conventional Banzhaf values algorithm evaluates the utility twice to do one update of the Banzhaf values, the Maximum Samples Reuse (MSR) algorithm promises higher sample efficiency because it updates multiple samples per one evaluation of the utility. This part of the notebook takes a look at the convergence speed of the algorithms compared with each other." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if is_CI:\n", + " max_checks = 10\n", + " moving_avg = 10\n", + "else:\n", + " max_checks = 10000\n", + " moving_avg = 200" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Monte Carlo Permutation Sampling Banzhaf semivalues\n", + "utility = Utility(\n", + " model=TorchCNNModel(),\n", + " data=dataset,\n", + " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", + ")\n", + "history_permutation = HistoryDeviation(n_steps=max_checks, rtol=1e-9)\n", + "permutation_values = compute_banzhaf_semivalues(\n", + " utility,\n", + " done=MaxChecks(max_checks + 2) | history_permutation,\n", + " n_jobs=-1,\n", + " progress=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# MSR Banzhaf values\n", + "history_msr = HistoryDeviation(n_steps=max_checks, rtol=1e-9)\n", + "msr_values = compute_msr_banzhaf_semivalues(\n", + " utility, done=MaxChecks(max_checks + 2) | history_msr, n_jobs=-1, progress=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# UniformSampler\n", + "history_uniform = HistoryDeviation(n_steps=max_checks, rtol=1e-9)\n", + "uniform_values = compute_banzhaf_semivalues(\n", + " utility,\n", + " sampler_t=UniformSampler,\n", + " done=MaxChecks(max_checks + 2) | history_uniform,\n", + " n_jobs=-1,\n", + " progress=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# AntitheticSampler\n", + "history_antithetic = HistoryDeviation(n_steps=max_checks, rtol=1e-9)\n", + "antithetic_values = compute_banzhaf_semivalues(\n", + " utility,\n", + " sampler_t=AntitheticSampler,\n", + " done=MaxChecks(max_checks + 2) | history_antithetic,\n", + " n_jobs=-1,\n", + " progress=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# RandomHierarchicalSampler\n", + "history_random = HistoryDeviation(n_steps=max_checks, rtol=1e-9)\n", + "random_values = compute_banzhaf_semivalues(\n", + " utility,\n", + " sampler_t=RandomHierarchicalSampler,\n", + " done=MaxChecks(max_checks + 2) | history_random,\n", + " n_jobs=-1,\n", + " progress=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Compare convergence speed of both methods\n", + "import numpy as np\n", + "\n", + "names = [\"Permutation\", \"MSR\", \"Uniform\", \"Antithetic\", \"RandomHierarchical\"]\n", + "all_values = [\n", + " history_permutation._memory,\n", + " history_msr._memory,\n", + " history_uniform._memory,\n", + " history_antithetic._memory,\n", + " history_random._memory,\n", + "]\n", + "distances = [[] for _ in names]\n", + "moving_avgs = []\n", + "\n", + "for sampler_id, name in enumerate(names):\n", + " for iteration in range(max_checks):\n", + " abs_dist = np.abs(\n", + " all_values[sampler_id][:, iteration]\n", + " - all_values[sampler_id][:, iteration + 1]\n", + " )\n", + " if abs_dist.max() == 0.0:\n", + " distances[sampler_id].append(0.0)\n", + " else:\n", + " distances[sampler_id].append(np.mean(abs_dist))\n", + " moving_avgs.append(\n", + " np.convolve(distances[sampler_id], moving_avg / moving_avg, mode=\"same\")\n", + " )\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", + "for sampler_id, name in enumerate(names):\n", + " ax.plot(list(range(max_checks)), moving_avgs[sampler_id], label=name)\n", + "ax.set_xlabel(\"Iteration\")\n", + "ax.set_ylabel(\"Mean semivalue change between iterations\")\n", + "ax.set_title(\"Convergence speed of different samplers\")\n", + "plt.yscale(\"log\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The plot above visualizes the convergence speed of different samplers used for Banzhaf semivalue calculation. It shows the average magnitude of how much the semivalues are updated in every step of the algorithm. As you can see, MSR Banzhaf converges much faster. After 1000 iterations (subsets tried), Monte Carlo Banzhaf has evaluated the marginal function about 5 times per data point. For maximum sample reuse, the semivalue of each data point was updated 1000 times. Due to this, the values converge much quicker." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "print(np.linalg.norm(permutation_values.values - msr_values.values))\n", + "print(spearmanr(permutation_values.values, msr_values.values))" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + }, + "vscode": { + "interpreter": { + "hash": "4e000971326892723e7f31ded70802f690c31c3620f59a0f99e594aaee3047ef" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/msr_banzhaf_spotify.ipynb b/notebooks/msr_banzhaf_spotify.ipynb deleted file mode 100644 index a303651de..000000000 --- a/notebooks/msr_banzhaf_spotify.ipynb +++ /dev/null @@ -1,1177 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Banzhaf Values for data valuation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This notebook shows how to compute Banzhaf values using pyDVL.\n", - "\n", - "In order to illustrate the practical advantages, we will predict the popularity of songs in the dataset [Top Hits Spotify from 2000-2019](https://www.kaggle.com/datasets/paradisejoy/top-hits-spotify-from-20002019), and highlight how data valuation can help investigate and boost the performance of the models. In doing so, we will describe the basic usage patterns of pyDVL.\n", - "\n", - "Recall that data value is a function of three things:\n", - "\n", - "1. The dataset.\n", - "2. The model.\n", - "3. The performance metric or scoring function.\n", - "\n", - "Below we will describe how to instantiate each one of these objects and how to use them for data valuation. Please also see the [documentation on data valuation](../../value/)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setup\n", - "\n", - "We begin by importing the main libraries and setting some defaults.\n", - "\n", - "
\n", - "\n", - "If you are reading this in the documentation, some boilerplate (including most plotting code) has been omitted for convenience.\n", - "\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "tags": [ - "hide" - ] - }, - "outputs": [], - "source": [ - "%load_ext autoreload" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "tags": [ - "hide" - ] - }, - "outputs": [], - "source": [ - "%autoreload\n", - "%matplotlib inline\n", - "\n", - "import os\n", - "import random\n", - "\n", - "import matplotlib.pyplot as plt\n", - "from sklearn.ensemble import GradientBoostingRegressor\n", - "from sklearn.metrics import mean_absolute_error\n", - "\n", - "plt.ioff() # Prevent jupyter from automatically plotting\n", - "plt.rcParams[\"figure.figsize\"] = (20, 6)\n", - "plt.rcParams[\"font.size\"] = 12\n", - "plt.rcParams[\"xtick.labelsize\"] = 12\n", - "plt.rcParams[\"ytick.labelsize\"] = 10\n", - "plt.rcParams[\"axes.facecolor\"] = (1, 1, 1, 0)\n", - "plt.rcParams[\"figure.facecolor\"] = (1, 1, 1, 0)\n", - "\n", - "is_CI = os.environ.get(\"CI\")\n", - "random_state = 24\n", - "random.seed(random_state)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will be using the following functions from pyDVL. The main entry point is the function `compute_banzhaf_semivalues()`.\n", - "In order to use it we need the classes [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset), [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility) and [Scorer](../../api/pydvl/utils/score/#pydvl.utils.score.Scorer)." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "%autoreload\n", - "from pydvl.reporting.plots import plot_shapley\n", - "from pydvl.utils.dataset import GroupedDataset\n", - "from support.shapley import load_spotify_dataset\n", - "from pydvl.value import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loading and grouping the dataset\n", - "\n", - "pyDVL provides a support function for this notebook, `load_spotify_dataset()`, which downloads data on songs published after 2014, and splits 30% of data for testing, and 30% of the remaining data for validation. The return value is a triple of training, validation and test data as lists of the form `[X_input, Y_label]`." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "training_data, val_data, test_data = load_spotify_dataset(\n", - " val_size=0.3, test_size=0.3, target_column=\"popularity\", random_state=random_state\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide" - ] - }, - "outputs": [], - "source": [ - "# In CI we only use a subset of the training set\n", - "if is_CI:\n", - " ci_test_artists = [\"Billie Eilish\", \"DJ Snake\", \"Eminem\", \"Adele\", \"Maroon 5\"]\n", - " training_data[0] = training_data[0][\n", - " training_data[0][\"artist\"].isin(ci_test_artists)\n", - " ]\n", - " training_data[1] = training_data[1][training_data[0].index]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
artistsongduration_msexplicityeardanceabilityenergykeyloudnessmodespeechinessacousticnessinstrumentalnesslivenessvalencetempogenre
1561Fetty Wap679 (feat. Remy Boyz)196693True20150.6180.7177-5.73810.31800.002560.0000000.62500.603190.0508
1410Meghan TrainorAll About That Bass187920True20150.8070.8879-3.72610.05030.057300.0000030.12400.961134.05214
1772Katy PerryChained To The Rhythm237733False20170.5620.8000-5.40410.11200.081400.0000000.19900.47195.02914
1670SigalaSweet Lovin' - Radio Edit202149False20150.6830.91010-1.23110.05150.055300.0000050.33600.674124.97715
1780Liam PayneStrip That Down204502False20170.8690.4856-5.59510.05450.246000.0000000.07650.527106.02814
\n", - "
" - ], - "text/plain": [ - " artist song duration_ms explicit year \\\n", - "1561 Fetty Wap 679 (feat. Remy Boyz) 196693 True 2015 \n", - "1410 Meghan Trainor All About That Bass 187920 True 2015 \n", - "1772 Katy Perry Chained To The Rhythm 237733 False 2017 \n", - "1670 Sigala Sweet Lovin' - Radio Edit 202149 False 2015 \n", - "1780 Liam Payne Strip That Down 204502 False 2017 \n", - "\n", - " danceability energy key loudness mode speechiness acousticness \\\n", - "1561 0.618 0.717 7 -5.738 1 0.3180 0.00256 \n", - "1410 0.807 0.887 9 -3.726 1 0.0503 0.05730 \n", - "1772 0.562 0.800 0 -5.404 1 0.1120 0.08140 \n", - "1670 0.683 0.910 10 -1.231 1 0.0515 0.05530 \n", - "1780 0.869 0.485 6 -5.595 1 0.0545 0.24600 \n", - "\n", - " instrumentalness liveness valence tempo genre \n", - "1561 0.000000 0.6250 0.603 190.050 8 \n", - "1410 0.000003 0.1240 0.961 134.052 14 \n", - "1772 0.000000 0.1990 0.471 95.029 14 \n", - "1670 0.000005 0.3360 0.674 124.977 15 \n", - "1780 0.000000 0.0765 0.527 106.028 14 " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "training_data[0].head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The dataset has many high-level features, some quite intuitive ('duration_ms' or 'tempo'), while others are a bit more cryptic ('valence'?). For information on each feature, please consult [the dataset's website](https://www.kaggle.com/datasets/paradisejoy/top-hits-spotify-from-20002019).\n", - "\n", - "In our analysis, we will use all the columns, except for 'artist' and 'song', to predict the 'popularity' of each song. We will nonetheless keep the information on song and artist in a separate object for future reference." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "song_name = training_data[0][\"song\"]\n", - "artist = training_data[0][\"artist\"]\n", - "training_data[0] = training_data[0].drop([\"song\", \"artist\"], axis=1)\n", - "test_data[0] = test_data[0].drop([\"song\", \"artist\"], axis=1)\n", - "val_data[0] = val_data[0].drop([\"song\", \"artist\"], axis=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Input and label data are then used to instantiate a [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset) object:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "dataset = Dataset(*training_data, *val_data)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The calculation of exact Banzhaf semivalues is computationally very expensive (exponentially so!) because it requires training the model on every possible subset of the training set. For this reason, PyDVL implements techniques to speed up the calculation, such as [Monte Carlo approximations](../../api/pydvl/value/shapley/montecarlo/), [surrogate models](../../api/pydvl/utils/utility/#pydvl.utils.utility.DataUtilityLearning) or [caching](../../api/pydvl/utils/caching/) of intermediate results and grouping of data to calculate group Shapley values instead of single data points.\n", - "\n", - "In our case, we will group songs by artist and calculate the Shapley value for the artists. Given the [pandas Series](https://pandas.pydata.org/docs/reference/api/pandas.Series.html) for 'artist', to group the dataset by it, one does the following:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "grouped_dataset = GroupedDataset.from_dataset(dataset=dataset, data_groups=artist)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Creating the utility and computing Banzhaf semivalues\n", - "\n", - "Now we can calculate the contribution of each group to the model performance.\n", - "\n", - "As a model, we use scikit-learn's [GradientBoostingRegressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html), but pyDVL can work with any model from sklearn, xgboost or lightgbm. More precisely, any model that implements the protocol [pydvl.utils.types.SupervisedModel](../../api/pydvl/utils/types/#pydvl.utils.types.SupervisedModel), which is just the standard sklearn interface of `fit()`,`predict()` and `score()` can be used to construct the utility.\n", - "\n", - "The third and final component is the scoring function. It can be anything like accuracy or $R^2$, and is set with a string from the [standard sklearn scoring methods](https://scikit-learn.org/stable/modules/model_evaluation.html). Please refer to that documentation on information on how to define your own scoring function.\n", - "\n", - "We group dataset, model and scoring function into an instance of [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility)." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "# Compute regular Banzhaf semivalue\n", - "utility = Utility(\n", - " model=GradientBoostingRegressor(n_estimators=3),\n", - " data=grouped_dataset,\n", - " scorer=Scorer(\"neg_mean_absolute_error\", default=0.0),\n", - ")\n", - "values = compute_banzhaf_semivalues(\n", - " utility,\n", - " # Stop if the standard error is below 1% of the range of the values (which is ~2),\n", - " # or if the number of updates exceeds 1000\n", - " done=AbsoluteStandardError(threshold=0.2, fraction=0.9) | MaxUpdates(1000),\n", - " n_jobs=-1,\n", - ")\n", - "values.sort(key=\"value\")\n", - "df = values.to_dataframe(column=\"data_value\", use_names=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's take a look at the returned dataframe:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
data_valuedata_value_stderr
5 Seconds of Summer-0.5819370.101380
Shawn Mendes-0.5527850.166859
Alessia Cara-0.5451590.054849
Liam Payne-0.4058000.262284
Kendrick Lamar-0.4057190.240342
\n", - "
" - ], - "text/plain": [ - " data_value data_value_stderr\n", - "5 Seconds of Summer -0.581937 0.101380\n", - "Shawn Mendes -0.552785 0.166859\n", - "Alessia Cara -0.545159 0.054849\n", - "Liam Payne -0.405800 0.262284\n", - "Kendrick Lamar -0.405719 0.240342" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let us plot the results. In the next cell we will take the 30 artists with the lowest score and plot their values with 95% Normal confidence intervals. Keep in mind that Monte Carlo Banzhaf is typically very noisy, and it can take many steps to arrive at a clean estimate." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input", - "invertible-output" - ] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "low_dvl = df.iloc[:30]\n", - "plot_shapley(\n", - " low_dvl,\n", - " level=0.05,\n", - " title=\"Artists with low values\",\n", - " xlabel=\"Artist\",\n", - " ylabel=\"Banzhaf value\",\n", - ")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can immediately see that many artists (groups of samples) have very low, even negative value, which means that they tend to decrease the total score of the model when present in the training set! What happens if we remove them?\n", - "\n", - "In the next cell we create a new training set excluding the artists with the lowest scores:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "low_dvl_artists = df.iloc[: int(0.2 * len(df))].index.to_list()\n", - "artist_filter = ~artist.isin(low_dvl_artists)\n", - "X_train_good_dvl = training_data[0][artist_filter]\n", - "y_train_good_dvl = training_data[1][artist_filter]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we will use this \"cleaned\" dataset to retrain the same model and compare its mean absolute error to the one trained on the full dataset. Notice that the score now is calculated using the test set, while in the calculation of the Shapley values we were using the validation set." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Improvement: 13.635495%\n" - ] - } - ], - "source": [ - "model_good_data = GradientBoostingRegressor(n_estimators=3).fit(\n", - " X_train_good_dvl, y_train_good_dvl\n", - ")\n", - "error_good_data = mean_absolute_error(\n", - " model_good_data.predict(test_data[0]), test_data[1]\n", - ")\n", - "\n", - "model_all_data = GradientBoostingRegressor(n_estimators=3).fit(\n", - " training_data[0], training_data[1]\n", - ")\n", - "error_all_data = mean_absolute_error(model_all_data.predict(test_data[0]), test_data[1])\n", - "\n", - "print(f\"Improvement: {100*(error_all_data - error_good_data)/error_all_data:02f}%\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The score has improved by almost 14%! This is quite an important result, as it shows a consistent process to improve the performance of a model by excluding data points from its training set." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - "\n", - "One must however proceed with caution instead of simply throwing away data. For one, `mean_absolute_error` is an estimate of generalization error on unseen data, so the improvement we see on the test set might not be as large upon deployment. It would be advisable to cross-validate this whole process to obtain more conservative estimates. It is also advisable to manually inspect the artists with low value and to try to understand the reason why the model behaves like it does. Finally, remember that **the value depends on the model chosen**! Artists that are detrimental to the Gradient Boosting Regressor might be informative for a different model (although it is likely that the worst ones share some characteristic making them \"bad\" for other regressors).\n", - "\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evaluation on anomalous data\n", - "\n", - "One interesting test is to corrupt some data and to monitor how their value changes. To do this, we will take one of the artists with the highest value and set the popularity of all their songs to 0." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input", - "invertible-output" - ] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "high_dvl = df.iloc[-30:]\n", - "ax = plot_shapley(\n", - " high_dvl,\n", - " title=\"Artists with high values\",\n", - " xlabel=\"Artist\",\n", - " ylabel=\"Banzhaf value\",\n", - ")\n", - "ax.get_xticklabels()[high_dvl.index.get_loc(\"Billie Eilish\")].set_color(\"red\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let us take all the songs by Billie Eilish, set their score to 0 and re-calculate the Banzhaf values." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - "/Users/jakobkruse/Documents/Projects/pyDVL/src/pydvl/parallel/backends/joblib.py:47: UserWarning: Cancellation of futures is not supported by the joblib backend\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "y_train_anomalous = training_data[1].copy(deep=True)\n", - "y_train_anomalous[artist == \"Billie Eilish\"] = 0\n", - "anomalous_dataset = Dataset(\n", - " x_train=training_data[0],\n", - " y_train=y_train_anomalous,\n", - " x_test=val_data[0],\n", - " y_test=val_data[1],\n", - ")\n", - "grouped_anomalous_dataset = GroupedDataset.from_dataset(anomalous_dataset, artist)\n", - "anomalous_utility = Utility(\n", - " model=GradientBoostingRegressor(n_estimators=3),\n", - " data=grouped_anomalous_dataset,\n", - " scorer=Scorer(\"neg_mean_absolute_error\", default=0.0),\n", - ")\n", - "values = compute_banzhaf_semivalues(\n", - " anomalous_utility,\n", - " done=AbsoluteStandardError(threshold=0.2, fraction=0.9) | MaxUpdates(1000),\n", - " n_jobs=-1,\n", - ")\n", - "values.sort(key=\"value\")\n", - "df = values.to_dataframe(column=\"data_value\", use_names=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let us now consider the low-value artists (at least for predictive purposes, no claims are made about their artistic value!) and plot the results" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input", - "invertible-output" - ] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "low_dvl = df.iloc[:30]\n", - "ax = plot_shapley(\n", - " low_dvl,\n", - " title=\"Artists with low data valuation scores\",\n", - " xlabel=\"Artist\",\n", - " ylabel=\"Banzhaf Value\",\n", - ")\n", - "ax.get_xticklabels()[low_dvl.index.get_loc(\"Billie Eilish\")].set_color(\"red\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And Billie Eilish (our anomalous data group) has moved from top contributor to having negative impact on the performance of the model, as expected!\n", - "\n", - "What is going on? A popularity of 0 for Billie Eilish's songs is inconsistent with listening patterns for other artists. In artificially setting this, we degrade the predictive power of the model.\n", - "\n", - "By dropping low-value groups or samples, one can often increase model performance, but by *inspecting* them, it is possible to identify bogus data sources or acquisition methods.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Maximum Sample Reuse Banzhaf\n", - "\n", - "Now, we want to use a method called Maximum Sample Reuse (MSR) which reuses samples for updating the Banzhaf values. The method is introduced by Wang et al. in the paper *Data Banzhaf: A Robust Data Valuation Framework for Machine Learning*." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/100 [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
data_valuedata_value_stderr
Liberty X-1.1438530.382673
BLACKPINK-1.0671600.442940
Liam Payne-0.7755980.530834
Reik-0.7752690.359365
Alessia Cara-0.7561350.402948
\n", - "" - ], - "text/plain": [ - " data_value data_value_stderr\n", - "Liberty X -1.143853 0.382673\n", - "BLACKPINK -1.067160 0.442940\n", - "Liam Payne -0.775598 0.530834\n", - "Reik -0.775269 0.359365\n", - "Alessia Cara -0.756135 0.402948" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "high_dvl = df.iloc[-30:]\n", - "ax = plot_shapley(\n", - " high_dvl,\n", - " title=\"Artists with high values\",\n", - " xlabel=\"Artist\",\n", - " ylabel=\"Banzhaf Value\",\n", - ")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "low_dvl = df.iloc[:30]\n", - "ax = plot_shapley(\n", - " low_dvl,\n", - " title=\"Artists with low values\",\n", - " xlabel=\"Artist\",\n", - " ylabel=\"Banzhaf value\",\n", - ")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Compare convergence speed of Banzhaf and MSR Banzhaf Values\n", - "\n", - "While the conventional Banzhaf values algorithm evaluates the utility twice to do one update of the Banzhaf values, the Maximum Samples Reuse (MSR) algorithm promises higher sample efficiency because it updates multiple samples per one evaluation of the utility. This part of the notebook takes a look at the convergence speed of the algorithms compared with each other." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - " 0%| | 0/100 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Compare convergence speed of both methods\n", - "import numpy as np\n", - "\n", - "bz_values = history_normal._memory\n", - "msr_values = history_msr._memory\n", - "bz_distances = []\n", - "msr_distances = []\n", - "for iteration in range(num_iterations):\n", - " bz_abs_dist = np.abs(bz_values[:, iteration] - bz_values[:, iteration + 1])\n", - " if bz_abs_dist.max() == 0.0:\n", - " bz_distances.append(0.0)\n", - " else:\n", - " bz_distances.append(np.mean(bz_abs_dist[bz_abs_dist > 0]))\n", - " msr_abs_dist = np.abs(msr_values[:, iteration] - msr_values[:, iteration + 1])\n", - " if msr_abs_dist.max() == 0.0:\n", - " msr_distances.append(0.0)\n", - " else:\n", - " msr_distances.append(np.mean(msr_abs_dist[msr_abs_dist > 0]))\n", - "\n", - "bz_moving_avg = np.convolve(bz_distances, np.ones(200) / 200, mode=\"same\")\n", - "\n", - "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", - "ax.plot(\n", - " list(range(num_iterations)), bz_moving_avg, label=\"MC Banzhaf distance (Moving Avg)\"\n", - ")\n", - "ax.plot(list(range(num_iterations)), msr_distances, label=\"MSR Banzhaf distance\")\n", - "ax.set_xlabel(\"Iteration\")\n", - "ax.set_ylabel(\"Mean Semivalue distance between two epochs\")\n", - "ax.set_title(\"Convergence speed of MC Banzhaf vs. MSR Banzhaf\")\n", - "ax.set_ylim([0, 0.3])\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The plot above visualizes the convergence speed of regular Banzhaf vs Maximum Sample Reuse Banzhaf. It shows the average magnitude of how much the semivalues are updated in every step of the algorithm. As you can see, MSR Banzhaf converges much faster. After 1000 iterations (subsets tried), Monte Carlo Banzhaf has evaluated the marginal function about 5 times per data point. For maximum sample reuse, the semivalue of each data point was updated on average 500 times. Due to this, the values converge much quicker." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|█████████▉| 99.98/100 [00:18<00:00, 5.48%/s] \n", - "100%|█████████▉| 99.97/100 [00:17<00:00, 5.60%/s] \n" - ] - } - ], - "source": [ - "mc_values = compute_banzhaf_semivalues(\n", - " u=utility, sampler_t=UniformSampler, done=MaxChecks(10000), n_jobs=-1, progress=True\n", - ")\n", - "msr_values = compute_msr_banzhaf_semivalues(\n", - " u=utility, done=MaxChecks(10000), n_jobs=-1, progress=True\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.4268817759913272\n", - "SignificanceResult(statistic=0.9189952335500745, pvalue=1.1286299472107335e-74)\n" - ] - } - ], - "source": [ - "from scipy.stats import spearmanr\n", - "\n", - "print(np.linalg.norm(mc_values.values - msr_values.values))\n", - "print(spearmanr(mc_values.values, msr_values.values))" - ] - } - ], - "metadata": { - "celltoolbar": "Edit Metadata", - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.2" - }, - "vscode": { - "interpreter": { - "hash": "4e000971326892723e7f31ded70802f690c31c3620f59a0f99e594aaee3047ef" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/support/banzhaf.py b/notebooks/support/banzhaf.py new file mode 100644 index 000000000..35f1ff9fc --- /dev/null +++ b/notebooks/support/banzhaf.py @@ -0,0 +1,42 @@ +from typing import Optional + +from sklearn.datasets import load_digits +from sklearn.model_selection import train_test_split + + +def load_digits_dataset( + test_size: float, val_size: float = 0.0, random_state: Optional[int] = None +): + """Loads the sklearn handwritten digits dataset. More info can be found at + https://scikit-learn.org/stable/datasets/toy_dataset.html#optical-recognition-of-handwritten-digits-dataset. + + :param test_size: fraction of points used for test dataset + :param val_size: fraction of points used for training dataset + :param random_state: fix random seed. If None, no random seed is set. + :return: A tuple of three elements with the first three being input and + target values in the form of matrices of shape (N,8,8) the first + and (N,) the second. + """ + try: + import torch + except ImportError as e: + raise RuntimeError( + "PyTorch is required in order to load the Digits Dataset" + ) from e + + digits_bunch = load_digits(as_frame=True) + x, x_test, y, y_test = train_test_split( + digits_bunch.data.values / 16.0, + digits_bunch.target.values, + train_size=1 - test_size, + random_state=random_state, + ) + if val_size > 0: + x_train, x_val, y_train, y_val = train_test_split( + x, y, train_size=(1 - val_size) / (1 - test_size), random_state=random_state + ) + else: + x_train, y_train = x, y + x_val, y_val = None, None + + return ((x_train, y_train), (x_val, y_val), (x_test, y_test)) From 7934056711519b4662d185ef6d64554a58e8c69b Mon Sep 17 00:00:00 2001 From: jakob1111996 Date: Thu, 4 Apr 2024 16:38:47 +0200 Subject: [PATCH 23/42] run banzhaf notebook to get outputs for documentation --- notebooks/msr_banzhaf_digits.ipynb | 746 ++++++++++++++++++++++++----- 1 file changed, 623 insertions(+), 123 deletions(-) diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb index 697afeb34..0d9ffb69d 100644 --- a/notebooks/msr_banzhaf_digits.ipynb +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -37,26 +37,32 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": { "tags": [ "hide" - ] + ], + "ExecuteTime": { + "end_time": "2024-04-04T12:53:41.393588Z", + "start_time": "2024-04-04T12:53:41.382947Z" + } }, - "outputs": [], "source": [ "%load_ext autoreload" - ] + ], + "outputs": [], + "execution_count": 1 }, { "cell_type": "code", - "execution_count": null, "metadata": { "tags": [ "hide" - ] + ], + "ExecuteTime": { + "end_time": "2024-04-04T12:53:41.954627Z", + "start_time": "2024-04-04T12:53:41.444795Z" + } }, - "outputs": [], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -78,8 +84,11 @@ "\n", "is_CI = os.environ.get(\"CI\")\n", "random_state = 24\n", + "n_jobs = -1\n", "random.seed(random_state)" - ] + ], + "outputs": [], + "execution_count": 2 }, { "cell_type": "markdown", @@ -91,15 +100,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:53:42.253300Z", + "start_time": "2024-04-04T12:53:41.955958Z" + } + }, "source": [ "%autoreload\n", "from pydvl.reporting.plots import plot_shapley\n", "from support.banzhaf import load_digits_dataset\n", "from pydvl.value import *" - ] + ], + "outputs": [], + "execution_count": 3 }, { "cell_type": "markdown", @@ -112,24 +126,27 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, - "tags": [] + "tags": [], + "ExecuteTime": { + "end_time": "2024-04-04T12:53:43.022566Z", + "start_time": "2024-04-04T12:53:42.254204Z" + } }, - "outputs": [], "source": [ "training_data, _, test_data = load_digits_dataset(\n", " test_size=0.3, random_state=random_state\n", ")" - ] + ], + "outputs": [], + "execution_count": 4 }, { "cell_type": "code", - "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -137,9 +154,12 @@ }, "tags": [ "hide" - ] + ], + "ExecuteTime": { + "end_time": "2024-04-04T12:53:43.026207Z", + "start_time": "2024-04-04T12:53:43.023737Z" + } }, - "outputs": [], "source": [ "# In CI we only use a subset of the training set\n", "training_data = list(training_data)\n", @@ -151,13 +171,18 @@ " training_data[0] = training_data[0][:200]\n", " training_data[1] = training_data[1][:200]\n", " max_checks = 1000" - ] + ], + "outputs": [], + "execution_count": 5 }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:53:43.221473Z", + "start_time": "2024-04-04T12:53:43.026926Z" + } + }, "source": [ "# Visualize some of the data\n", "fig, axes = plt.subplots(2, 2, figsize=(4, 4))\n", @@ -168,7 +193,22 @@ "plt.suptitle(\"Example images from the dataset\")\n", "plt.tight_layout()\n", "plt.show()" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "execution_count": 6 }, { "cell_type": "markdown", @@ -179,12 +219,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:53:43.224251Z", + "start_time": "2024-04-04T12:53:43.222074Z" + } + }, "source": [ "dataset = Dataset(*training_data, *test_data)" - ] + ], + "outputs": [], + "execution_count": 7 }, { "cell_type": "markdown", @@ -203,9 +248,12 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:53:44.248491Z", + "start_time": "2024-04-04T12:53:43.224805Z" + } + }, "source": [ "import torch\n", "from torch import nn, optim\n", @@ -260,7 +308,7 @@ " )\n", " )\n", " pred = torch.argmax(pred, dim=1)\n", - " return pred.numpy()\n", + " return pred.cpu().numpy()\n", "\n", " def score(self, x: NDArray, y: NDArray) -> float:\n", " pred = self.predict(x)\n", @@ -275,13 +323,27 @@ "model.fit(x=training_data[0], y=training_data[1])\n", "print(f\"Train Accuracy: {model.score(x=training_data[0], y=training_data[1]):.3f}\")\n", "print(f\"Test Accuracy: {model.score(x=test_data[0], y=test_data[1]):.3f}\")" - ] + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Accuracy: 0.530\n", + "Test Accuracy: 0.435\n" + ] + } + ], + "execution_count": 8 }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:55:26.010464Z", + "start_time": "2024-04-04T12:53:44.249391Z" + } + }, "source": [ "# Compute regular Banzhaf semivalue\n", "utility = Utility(\n", @@ -290,11 +352,24 @@ " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", ")\n", "values = compute_banzhaf_semivalues(\n", - " utility, done=MaxChecks(max_checks), n_jobs=-1, progress=True\n", + " utility, done=MaxChecks(max_checks), n_jobs=n_jobs, progress=True\n", ")\n", "values.sort(key=\"value\")\n", "df = values.to_dataframe(column=\"data_value\", use_names=True)" - ] + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
data_valuedata_value_stderr
39-0.8695270.042223
130-0.8634770.004781
66-0.8329240.000774
153-0.6042380.037897
32-0.5700900.182911
\n", + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 10 }, { "cell_type": "markdown", @@ -321,7 +470,6 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -330,9 +478,12 @@ "tags": [ "hide-input", "invertible-output" - ] + ], + "ExecuteTime": { + "end_time": "2024-04-04T12:55:26.221110Z", + "start_time": "2024-04-04T12:55:26.021845Z" + } }, - "outputs": [], "source": [ "low_dvl = df.iloc[:30].copy()\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -344,7 +495,22 @@ " ylabel=\"Banzhaf value\",\n", ")\n", "plt.show()" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "execution_count": 11 }, { "cell_type": "markdown", @@ -359,7 +525,6 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -368,13 +533,38 @@ "tags": [ "hide-input", "invertible-output" - ] + ], + "ExecuteTime": { + "end_time": "2024-04-04T12:55:26.225053Z", + "start_time": "2024-04-04T12:55:26.221802Z" + } }, - "outputs": [], "source": [ "high_dvl = df.iloc[-10:].copy()\n", "print(f\"Average value of first 10 data points: {high_dvl['data_value'].mean()}\")\n", "print(f\"Exact values:\\n{high_dvl['data_value']}\")" + ], + "execution_count": 12, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average value of first 10 data points: 0.4317312540895265\n", + "Exact values:\n", + "49 0.307256\n", + "120 0.320427\n", + "80 0.322495\n", + "102 0.344323\n", + "62 0.392833\n", + "5 0.397684\n", + "115 0.438929\n", + "76 0.496701\n", + "71 0.636801\n", + "9 0.659862\n", + "Name: data_value, dtype: float64\n" + ] + } ] }, { @@ -386,9 +576,12 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:55:26.712480Z", + "start_time": "2024-04-04T12:55:26.225749Z" + } + }, "source": [ "x_train_anomalous = training_data[0].copy()\n", "y_train_anomalous = training_data[1].copy()\n", @@ -414,13 +607,31 @@ "plt.suptitle(\"Original and noisy versions of images 6-10\")\n", "plt.tight_layout()\n", "plt.show()" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "execution_count": 13 }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:57:03.603757Z", + "start_time": "2024-04-04T12:55:26.713469Z" + } + }, "source": [ "anomalous_dataset = Dataset(\n", " x_train=x_train_anomalous,\n", @@ -435,11 +646,24 @@ " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", ")\n", "anomalous_values = compute_banzhaf_semivalues(\n", - " anomalous_utility, done=MaxChecks(max_checks), n_jobs=-1, progress=True\n", + " anomalous_utility, done=MaxChecks(max_checks), n_jobs=n_jobs, progress=True\n", ")\n", "anomalous_values.sort(key=\"value\")\n", "anomalous_df = anomalous_values.to_dataframe(column=\"data_value\", use_names=True)" - ] + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00" + ], + "image/png": "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" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "execution_count": 15 }, { "cell_type": "markdown", @@ -510,9 +751,12 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:57:03.758502Z", + "start_time": "2024-04-04T12:57:03.754761Z" + } + }, "source": [ "print(\n", " f\"Average value of original data points: {plot_data['original_data_value'].mean()}\"\n", @@ -526,7 +770,26 @@ "print(anomalous_df.mean())\n", "print(\"These are the average data values of all points (original data):\")\n", "print(df.mean())" - ] + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average value of original data points: 0.4317312540895265\n", + "Average value of modified, anomalous data points: -0.039424471827874424\n", + "For reference, these are the average data values of all data points used for training (anomalous):\n", + "data_value -0.009905\n", + "data_value_stderr 0.112510\n", + "dtype: float64\n", + "These are the average data values of all points (original data):\n", + "data_value -0.011644\n", + "data_value_stderr 0.104547\n", + "dtype: float64\n" + ] + } + ], + "execution_count": 16 }, { "cell_type": "markdown", @@ -541,9 +804,12 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:57:16.038481Z", + "start_time": "2024-04-04T12:57:03.759362Z" + } + }, "source": [ "# Compute MSR Banzhaf semivalue\n", "utility = Utility(\n", @@ -554,27 +820,118 @@ "values = compute_msr_banzhaf_semivalues(\n", " utility,\n", " done=RankStability(0.0001),\n", - " n_jobs=-1,\n", + " n_jobs=n_jobs,\n", " progress=True,\n", ")\n", "values.sort(key=\"value\")\n", "msr_df = values.to_dataframe(column=\"data_value\", use_names=True)" - ] + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/100 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
data_valuedata_value_stderr
176-0.0642110.027643
61-0.0552450.027234
36-0.0503180.026853
44-0.0465960.027569
159-0.0421540.026803
\n", + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 18 }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:57:16.337771Z", + "start_time": "2024-04-04T12:57:16.044916Z" + } + }, "source": [ "high_dvl = df.iloc[-30:]\n", "high_dvl.index = high_dvl.index.map(str)\n", @@ -585,13 +942,31 @@ " ylabel=\"Banzhaf Value\",\n", ")\n", "plt.show()" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "execution_count": 19 }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T12:57:16.479270Z", + "start_time": "2024-04-04T12:57:16.338455Z" + } + }, "source": [ "low_dvl = df.iloc[:30]\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -602,7 +977,22 @@ " ylabel=\"Banzhaf value\",\n", ")\n", "plt.show()" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "execution_count": 20 }, { "cell_type": "markdown", @@ -615,9 +1005,12 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T14:22:50.796981Z", + "start_time": "2024-04-04T14:22:50.794652Z" + } + }, "source": [ "if is_CI:\n", " max_checks = 10\n", @@ -625,13 +1018,18 @@ "else:\n", " max_checks = 10000\n", " moving_avg = 200" - ] + ], + "outputs": [], + "execution_count": 46 }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T13:13:10.835392Z", + "start_time": "2024-04-04T12:57:16.482609Z" + } + }, "source": [ "# Monte Carlo Permutation Sampling Banzhaf semivalues\n", "utility = Utility(\n", @@ -643,29 +1041,62 @@ "permutation_values = compute_banzhaf_semivalues(\n", " utility,\n", " done=MaxChecks(max_checks + 2) | history_permutation,\n", - " n_jobs=-1,\n", + " n_jobs=n_jobs,\n", " progress=True,\n", ")" - ] + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00 0]))\n", " moving_avgs.append(\n", - " np.convolve(distances[sampler_id], moving_avg / moving_avg, mode=\"same\")\n", + " np.convolve(distances[sampler_id], np.ones(moving_avg) / moving_avg, mode=\"same\")\n", " )\n", "\n", - "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", + "fig, ax = plt.subplots(1, 1, figsize=(10, 5))\n", "for sampler_id, name in enumerate(names):\n", " ax.plot(list(range(max_checks)), moving_avgs[sampler_id], label=name)\n", "ax.set_xlabel(\"Iteration\")\n", "ax.set_ylabel(\"Mean semivalue change between iterations\")\n", "ax.set_title(\"Convergence speed of different samplers\")\n", "plt.yscale(\"log\")\n", + "plt.ylim(1e-5, 1)\n", "plt.legend()\n", "plt.show()" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "execution_count": 50 }, { "cell_type": "markdown", @@ -766,15 +1252,29 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-04T14:35:53.216582Z", + "start_time": "2024-04-04T14:35:53.211681Z" + } + }, "source": [ "from scipy.stats import spearmanr\n", "\n", "print(np.linalg.norm(permutation_values.values - msr_values.values))\n", "print(spearmanr(permutation_values.values, msr_values.values))" - ] + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.951534782455586\n", + "SignificanceResult(statistic=0.1615150378759469, pvalue=0.02232027439671079)\n" + ] + } + ], + "execution_count": 51 } ], "metadata": { From c6eb0636a805eb9310700fc103fe39ba875bfac7 Mon Sep 17 00:00:00 2001 From: jakob1111996 Date: Thu, 4 Apr 2024 16:42:34 +0200 Subject: [PATCH 24/42] linter for banzhaf notebook --- notebooks/msr_banzhaf_digits.ipynb | 707 ++++++++++++----------------- 1 file changed, 288 insertions(+), 419 deletions(-) diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb index 0d9ffb69d..72e57761b 100644 --- a/notebooks/msr_banzhaf_digits.ipynb +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -37,32 +37,26 @@ }, { "cell_type": "code", + "execution_count": 1, "metadata": { "tags": [ "hide" - ], - "ExecuteTime": { - "end_time": "2024-04-04T12:53:41.393588Z", - "start_time": "2024-04-04T12:53:41.382947Z" - } + ] }, + "outputs": [], "source": [ "%load_ext autoreload" - ], - "outputs": [], - "execution_count": 1 + ] }, { "cell_type": "code", + "execution_count": 2, "metadata": { "tags": [ "hide" - ], - "ExecuteTime": { - "end_time": "2024-04-04T12:53:41.954627Z", - "start_time": "2024-04-04T12:53:41.444795Z" - } + ] }, + "outputs": [], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -86,9 +80,7 @@ "random_state = 24\n", "n_jobs = -1\n", "random.seed(random_state)" - ], - "outputs": [], - "execution_count": 2 + ] }, { "cell_type": "markdown", @@ -100,20 +92,15 @@ }, { "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2024-04-04T12:53:42.253300Z", - "start_time": "2024-04-04T12:53:41.955958Z" - } - }, + "execution_count": 3, + "metadata": {}, + "outputs": [], "source": [ "%autoreload\n", "from pydvl.reporting.plots import plot_shapley\n", "from support.banzhaf import load_digits_dataset\n", "from pydvl.value import *" - ], - "outputs": [], - "execution_count": 3 + ] }, { "cell_type": "markdown", @@ -126,27 +113,24 @@ }, { "cell_type": "code", + "execution_count": 4, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, - "tags": [], - "ExecuteTime": { - "end_time": "2024-04-04T12:53:43.022566Z", - "start_time": "2024-04-04T12:53:42.254204Z" - } + "tags": [] }, + "outputs": [], "source": [ "training_data, _, test_data = load_digits_dataset(\n", " test_size=0.3, random_state=random_state\n", ")" - ], - "outputs": [], - "execution_count": 4 + ] }, { "cell_type": "code", + "execution_count": 5, "metadata": { "editable": true, "slideshow": { @@ -154,12 +138,9 @@ }, "tags": [ "hide" - ], - "ExecuteTime": { - "end_time": "2024-04-04T12:53:43.026207Z", - "start_time": "2024-04-04T12:53:43.023737Z" - } + ] }, + "outputs": [], "source": [ "# In CI we only use a subset of the training set\n", "training_data = list(training_data)\n", @@ -171,36 +152,19 @@ " training_data[0] = training_data[0][:200]\n", " training_data[1] = training_data[1][:200]\n", " max_checks = 1000" - ], - "outputs": [], - "execution_count": 5 + ] }, { "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2024-04-04T12:53:43.221473Z", - "start_time": "2024-04-04T12:53:43.026926Z" - } - }, - "source": [ - "# Visualize some of the data\n", - "fig, axes = plt.subplots(2, 2, figsize=(4, 4))\n", - "for i in range(4):\n", - " ax = axes[i % 2, i // 2]\n", - " ax.imshow(np.reshape(training_data[0][i], (8, 8)), cmap=\"grey\")\n", - " ax.set_xlabel(f\"Label: {training_data[1][i]}\")\n", - "plt.suptitle(\"Example images from the dataset\")\n", - "plt.tight_layout()\n", - "plt.show()" - ], + "execution_count": 6, + "metadata": {}, "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWkAAAGJCAYAAABIP8LMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAApEElEQVR4nO3de7wcdX3/8debAOGWi9yFiEcEf1qhRLQI1Evwyg+sgAWvtATbh/dqRNvKo7Wc4AUvVIPVarVK8FdUFCSxAoIXkoJiUixBK1qkGAQSrpJwDxA+vz++s7BsZk/O7Dk7892z7+fjsY9zznfmO/OZOZ/97Ox3ZmcVEZiZWZ62aDoAMzPrzkXazCxjLtJmZhlzkTYzy5iLtJlZxlykzcwy5iJtZpYxF2kzs4y5SJuZZcxFehJIWi1pdR+Xv1hSSBrp1zqmMklbSVoo6TeSNhT78uim4+oXSSPFNi5uOpZOkuYXsc1vOpZBUblIFzt4c495kx+qWc/eB/wDsAY4HVgI/LrRiCaoeJ4tazqOpkgaHZRaM9FYt5zAuheOMW31BJZrmzoZ+Bhwc9OBDKhXAfcCL4+Ih5oOxqyKnot0RIxOYhw2hohYC6xtOo4Btgdwpwu0DaSIqPQAInUb17xPA9YBvwee2jFte+BXwEZgXlv7M0hHjVcCtwMbgBuALwJzStYxr4hpFHge8D1gPXAXcB7wlGK+vYFvFMt8ALgUOKBkeYuL5e0NnER6W/wgcBPwaWBmSZ/VwOou++ANxbrWFcv5FfD3wPQK+7wV00hb20jRthh4OnAucCdwD3AJsF8x3y7FvltbrP8/gcNK1rEHaUjgx8AtwEOk4YGvAX/QJS4B7wGuKZZ9M/BZYNZk7RPghcC/F/t/QxHbT4FTKuy3zsfqkn34DOAc4DbgUYqcJA0Jvq3Yb/cC9xW/vx3YosvzYxmwG/AV4Naiz0+AF7bl/idJeb0B+CVw3DhzYX6XbQpgtGS7Rkh5f0exr68EXjXG8iecr8Vy9gG+RXoetrb/yLb453fMfxgpT68B7iY9R/8bOAXYpuT5VroPJlBHBJxQxHl7se03AhcDryuZfw4p168vln0n8B3gj6rGutl9WWXHtyXh+FcAxxZ9fgxs2dZ+VtF+Ssf8HygS5HzgM6QxxItIT5y1wJ4d888rlnNB8Y/9XtHn4qL9f4BnFkl6OfCPpIL2KOkJuUOXJ/bSIsH+Bfg4sKpov7JL0mxSkEhP0ij+2V8u1v3jou3S9v0xzmJTVqSXFdt2WbH884ptuwPYF/hf4CpgEfBVUvF9ENirYx2vB+4v9uPnim3+djH/vZS/oP1zEcPNbf+ra4GVRduE9glwOOlF/K4iXz4KfAFYDtw6jv12NOnFe13xGC0eCzr24WXFOlaQXoi/ABxYzHN2Mc/vin34aR5/4p3d5fmxCriuZL/fDxxAepG5ttjPXyS9sD4KHDyObZpbbEMUcYy2PeZ1bNelpBz/aRH3WcX/fiPlL9STla/7kvIvgAuL/9s3gYdJhaysSH+v2J6vkV7A/gn4r7Z1T2ubdwEp71svRI/tgwnUkY8Wy7u++L98FDiT9EJxbse8Bxbb92ixzNOLONaRCvYRVWLtW5HuSI72xwfGeDKfVvx9QvH3j+g4GgH2pPyI6hVFcn2+S5EO4E0d075ctP8e+LuOaR8spr2nS0G8g7ajf9IR1XnFtA929FlNR0Hi8SOGbwPbdkwbLVv3GPu8FVNZkY4xtu33pIKzRdu0Pyumfbqjz67AjJJ1H0Aq0hd1tL+Qx18EZ7e1bw38B21HrL3uk7b9fUBJXDtXyNlN/j8l+/CjJdPfUEz7L9pezElHwlcW097Y5fnRbb//nvTOYJu2aa19eX7F5+GyLtPat+uUjmmvLNov7GO+XlI2P3BUW1zzO6btDahkWR8q5n9dl5jmdYmhah25k/Rubbuxco00RHwd6cXuxR3z7UE6OFnbvu7NxbrZ/Vm5Q/e3Wq3HupI+25COLh4F3kV60t8GPLniun8OXN/RNq9Y72Ul87+omPZb2l6Ji2lPLaad2dG+mJJC3JZIG4HfdrSvZtOCdBXpyGF2yXKmkV4EVo5zu1sxjbS1jYyxbXsV0+6jo/AW634YuLTCfv9OkZRbtbX9a7GOPy+Z/48pL9KV9gmPF+ln9JLcY/1/OvbhLZQ/ob9fTH9FybSXFtN+VPL8GGu/B7B3yfJ+25lXm9mm8RTp1Z25UUy/AbijH/lKGgYI0hFp2bqXUVKkx1jejsX8X+loH6XHwkd5Hbmz+B+MOazD4y80n+wy/T3F9CMmI9aImNCJQ1WY90FJryMdffxTEfCxkU6IPYEkAW8ivbIfADyJlCQt3U7+XFnStqb4uSoiNnZMa10pMafL8pZ3NkTE9ZJuBEYkzY6IdWUdJW1XxH4HsCBt0iY2AM/qsu4qyrattd3XRsQ97RMiYqOkWynZbklHksZfnwfszKYnlnfm8ROYzyl+Xl4S00+BRzqW3cs+ORt4DbBC0jmkt70/joibyjpPwNURsaGk/UDSgcWykmnLSS/YzymZNtZ+3z4iri/pczPw/EpRb15ZbkAazjik9cck5+tjedFl3cuAF3c2StqeVOCOIY0nzyCNE7fsOY51ty+vah05G/gr4BpJ3yT9f6+IiPUd87X221MljZaset/i57NIQz0TNpFL8Kq6lvQKdijp5MAlXeb7FGkcZy1pXPlm0lgzpB3+1C79OncmPF4oNpkWEY8UybhVl+Xd2qX9liKGWaQxqDJPIiXYLqQTH/001raV7RNI++UJ2y3pPaTx07tIR5C/I42hBmls9wBgeluXWcXPTfZTUZDu7GiuvE8i4tuSXkW6zvnNwFuLWH8GnBwR3x/Pcsbhli7ts4DfR8lVIcU+voM0TNRprP0+1rTJfj6uG2Nd7Z+RmMx87ZoXhU32taStSEOfB5HGgM8hnbx7uJjlFJ6Ye+NRtY68l3T0fyJpPPsDwCOSLgTeFxHXFfPtVPw8bjPr36FivF3VWaQ/QCrQdwDPJl37+5H2GSTtCryb9I86tPNoRNIb6gkVSGfn/6ekfffiZ7cnW/u0qyLiwEmNqg8kbUl6S3YL6YTZ2o7ph5R0u7v4uRspudvnn0ZK5vbrunvaJxFxAXBBcaT1fNI1z28HvivpORFxzXiXNdZqurSvB3aUtFVEPNw+odhnO/P4fhhkk5mvrWXt1mX67iVtR5EK9OKIOLF9gqQnU/GFo5c6Uhz1LwIWFf1fQDqZfhzwbEnPLt5ttbbvqIj4TpW4elXLx8IlHQqcSip6+xU/F0p6QcesexcxXVKyY+cU0+tS9pZsb+AppPHNdd06RsS9pMuqni1px75FOHl2BmYDPykp0DuQ3vZ3uqr42fk/BDiYjgOAie6TiLgvIn4UESeRzrxvDfzfqsup6CpSPr6oZNqLSG+f/6vPMXTzKE98+96zSc7Xx/KieLHuNK+kbZ/i57dLpm3yPCy0hlLK1jGhOhIRt0XEtyPitaQj/KeT6hakoTxIJ3vHa6xYN6vvRVrSk4CvkwJ9fUTcCryO9Jbrax1Jsbr4+YR/cFEovkS9R/7vkfTYWyJJW5AuDdqCdGnO5nyKVEi+Iml250RJT5KUy1H2baShjecW+xp47G3oGaQi3umrxc+/kzSrrc/WpCJaptI+kfSi4oi1U+so7f6uWzQ5vlL8PK0Yt23FtR3pGlxIVxA14U7SAcNkmZR8Lc4XfJ/0GYl3dSzjKMqL7uri57yO+fcmXQpapjWcttcYyxtXHZE0XdIfdy6kyP9WfWrl2lLSZa3vlHREWWCSDmnPl83Eulk9F70ug+YtSyJiVfH7V0jBvbvVFhFXS3of6WLwxcCri/ZbJH2D9DZjlaRLSGNcLyddXbCKdJ1oHX5cxHAO6S3OK0njsj8DPrG5zhHxFUnPBd4B/K+ki0njvDuSEvhFpGL/tv6EP34R8aikz5CGpH4haSnpCXsYKd5Li9/b+yyX9EXgLcAvJZ1HGkP8E9L+WkM62mvvU3WffAbYU9KPSU+8h4DnAi8hXaHwjUncDZuIiK8VheW1xTYu4fEx+qcB50TE2f2MYQw/BF4v6d9JR/MPA/8REf/Ry8ImOV/fCVxBGjp4BXA16Wj5GNLlh3/SMf+/ky5rO0nS/qSj8b1IQ1sXUF7cLiXl12mS9iOdSyEiPtxDHdkWuFzSdaTn9w2kK9JeTjoB+J2I+FWx/IclvYY0zn2BpJ8Uy7uf9KL5R6Qj9SfzeGHvGuvmdyV9uQTvsctrSGdLA1jaZVnfLqa/t61tO9JYdetaxBtJF5fvRHH5Tscy5hXLGC1Z/kgxbfEY27Kso21x0b436YRV6xOHN5PGrKp+4vBVwHdJR6sPkcZ9VwIfBp45zn3eimlkIts2VrykF+yTSCd1Hyji/H+kEyybrL/oswXphMuvSWf/1xT/q1mkD2ismsg+IRXHrwO/IV22eTdpnPEjwC4Vcrb0/7O5fdi2je8gXT10f/H4GakQdf3EYZU4immb5PZmtmlX0gc/biW9S33sOTCO3Oi6rsnI12I5+5A+NLaOdEniFYz9icOnkK6waJ3g+yXwN0Velu5T4HhSgXygmCfapo27jpBOov8N6YMpvyvmv500tPE2YOsu+/9jRT7eX+Tnb4ptPp6OD/6MFevmHioWYAWl2zueADwtIlY3G81gkrQv6Wqeb0REnSd7zaYc30/aeiZp92Ksvr1tO9I7DkgfyTWzCajzRJxNPQuANyjd13gt6fKql5I+KHMR6QY7ZjYBLtI2Ed8nnUx9BekE0yOkYY7PAIvCY2lmE+YxaTOzjHlM2swsYy7SZmYZc5E2M8uYi7SZWcZcpM3MMuYibWaWMRdpM7OMuUibmWXMRdrMLGMu0mZmGXORNjPLmIu0mVnGXKTNzDLmIm1mljEXaTOzjLlIm5llzEXazCxjLtJmZhlzkTYzy5iLtJlZxlykzcwy5iJtZpYxF2kzs4y5SJuZZcxF2swsY1s2HcB4SRKwB3BP07FYqRnAmoiIpgOZapz72etr7g9MkSYl6U1NB2FjmgPc3HQQU5BzP399y/1BKtK1HUVcfvnllfvsv//+fYhkU+vXr6/c5wUveEHlPr/73e8q98FHev1S237tJY/f8Y53VO7zxje+sXKfXhx55JGV+/Ty/KeP/6NBKtK12WGHHSr3mTlzZh8i2VQv76i22MKnHmx8pk2bVrnPtttuW7lPXc+XLbcc/BJX67NX0jslrZb0oKQVkg6qc/1mTXHuW69qK9KSXgd8ClgIHAhcDVwsade6YjBrgnPfJqLOI+mTgC9FxJkRcQ3wNuB+4M1lM0uaLmlm60E6g2o2iJz71rNairSkrYHnAj9otUXEo8Xfh3TpdjKwvu3hs9s2cJz7NlF1HUnvDEwDbu1ovxXYvUuf04BZbY85fYvOrH+c+zYh2Z76jIgNwIbW3+l6frOpz7lv7eo6kr4D2Ajs1tG+G3BLTTGYNcG5bxNSS5GOiIeAnwEvbbVJ2qL4+4o6YjBrgnPfJqrO4Y5PAWdJuhJYCSwAtgfOrDEGsyY4961ntRXpiDhH0i7AqaQTJquAwyOi84RK42bPnl25z9VXX125z+rVqyv3Oeqooyr3sWYNUu6vWrWqcp/58+dX7rNgwYLKfXqJbe7cuZX7LFu2rHKffqr1xGFEfBb4bJ3rNMuBc9965Zs6mJllzEXazCxjLtJmZhlzkTYzy5iLtJlZxlykzcwy5iJtZpYxF2kzs4y5SJuZZcxF2swsYy7SZmYZy/am/03q5UYuIyMjlfvMmzevcp8TTzyxcp9ebuRk1k+93MSslz69PJdz4yNpM7OMuUibmWXMRdrMLGMu0mZmGXORNjPLmIu0mVnGXKTNzDLmIm1mljEXaTOzjLlIm5llzEXazCxjLtJmZhnzDZZKnHnmmZX7LFmypHKfs846q3KfxYsXV+5jNl693PSrF6Ojo7WsZ9asWbWsp598JG1mljEXaTOzjLlIm5llzEXazCxjLtJmZhlzkTYzy5iLtJlZxlykzcwy5iJtZpYxF2kzs4y5SJuZZcxF2swsY77BUoljjjmmcp8bbrihcp+jjz66ch+z8Zo9e3blPr3cKKyumxidccYZlfusX7++D5HUy0fSZmYZc5E2M8uYi7SZWcZcpM3MMuYibWaWMRdpM7OMuUibmWXMRdrMLGMu0mZmGXORNjPLmIu0mVnGXKTNzDKmiGg6hnGRNBOofLeUXm4ys2rVqsp9erlZ0rJlyyr3GR0drdxn0aJFlfv0aFZE3F3XyoZFr7nfi5GRkcp9esmvXtYzd+7cyn1q1Lfc95G0mVnGXKTNzDJWS5GWNCopOh6/rmPdZk1y7ttE1XnT/18CL2v7+5Ea123WJOe+9azOIv1IRNxS4/rMcuHct57VOSa9r6Q1kq6XdLakvcaaWdJ0STNbD2BGTXGaTTbnvvWsriK9ApgPHA68HXgacJmksZLvZNJlR63HTX2O0awfnPs2IbUU6Yi4KCK+FRE/j4iLgSOA2cBrx+h2GjCr7TGn74GaTTLnvk1UI98WHhHrJF0L7DPGPBuADa2/JdURmllfOfetqkauk5a0A/B0YG0T6zdrinPfqqrrOunTJb1Y0oikQ4HzgY3A1+tYv1lTnPs2UXUNd8whJeVOwO3A5cDBEXF7Tes3a4pz3yakliIdEa+vYz1lernxUS83WOqlTy/WrVtXy3pscjSZ+73oJb+OOuqoyn16eV4OK9+7w8wsYy7SZmYZc5E2M8uYi7SZWcZcpM3MMuYibWaWMRdpM7OMuUibmWXMRdrMLGMu0mZmGXORNjPLmIu0mVnGGrnpf52WLFlSuc+CBQsq94mIyn3Wr19fuU9dN3Ky4TQyMlK5z/Llyyv3Wbp0aeU+w8pH0mZmGXORNjPLmIu0mVnGXKTNzDLmIm1mljEXaTOzjLlIm5llzEXazCxjLtJmZhlzkTYzy5iLtJlZxqb8vTt6uafGvffeW7nP3XffXUufjRs3Vu5jNl695Nd9993Xh0isRb0UsSZI2hO4qek4bExzIuLmpoOYapz7A6FvuT9IRVrAHsA9HZNmkBJ4Tsm0YZHDPpgBrIlBSagB4twfUw77oK+5PzDDHcUO2OSVKuUvAPdERPXxgykgk30wlPu+Ds797jLZB31dr08cmpllzEXazCxjU6FIbwAWFj+HlffBcPL/fQj2wcCcODQzG0ZT4UjazGzKcpE2M8uYi7SZWcZcpM3MMuYibWaWsYEt0pKmS/q4pDWSHpC0QtLLm46rLpLmSYouj4Objs/6x7k/XLk/MB8LL7EYOBZYBPwGmA9cKOmwiLi8ubBq9xngPzvarmsiEKvNYpz7MCS5P5DXSUs6CFgB/HVEnF60bQP8N3BbRBzaZHx1kDQPuBQ4LiLObTYaq4tzf/hyf1CHO44FNgJfbDVExIPAl4FDJD2lqcCaIGmGpEF+V2Tj59xvMwy5P6hF+jnAtSV3vVpZ/JxbbziNOpN0F64HJV0q6XlNB2R95dx/3FDk/qC+Aj0ZWFvS3mrbo8ZYmvIQcB5wIXAH8AfA+4HLJB0aEVc1GZz1jXN/yHJ/UIv0tpTfUOXBtulTWkT8BPhJW9N3JJ0L/Bw4DTi8kcCs35z7Q5b7gzrc8QAwvaR9m7bpQycirgOWAodJmtZ0PNYXzv0SUzn3B7VIryW97evUaltTYyy5uRHYGti+6UCsL5z73U3J3B/UIr0KeIakmR3tz2+bPqz2Jr31rf6V5zYIVuHc72ZK5v6gFulzgWnAW1oNkqYDJwIrIuLGpgKri6RdStoOAF4NXBIRj9YfldXAuT9kuT+QJw4jYoWkbwGnSdqV9CmjE4AR4C+ajK1G50h6gHQC5TbSGe63APcDH2gyMOsf5z4wZLk/kJ84hMc+ZfUh4HjgSaQzux+MiIsbDawmkt4NvAnYB5gJ3A78EFhYnESxKcq5P1y5P7BF2sxsGAzqmLSZ2VBwkTYzy5iLtJlZxlykzcwy5iJtZpYxF2kzs4y5SJuZZcxF2swsYy7Sk0DSSPFNxe+fxGW2vhF53mQt02yyOff7b2iLtKT5RSJMya/cAZD0suJrhe6QtE7SSkl/1nRc1qypnvuSVhfbV/b4TdPxVTWQN1iyzZP0amAJcAUwCgTwWuCrknaOiE83F51ZXy0AduhoeyrwYeCS2qOZIBfpqetdpBvEvyQiNgBI+hfg18B8wEXapqSIWNLZJunvi1/PrjeaiRva4Y7xkLS1pFMl/UzSekn3SbpM0mFj9HmvpBskPSBpuaT9SuZ5pqRzJf1e0oOSriyOfDcXz3ZF353HEf5M4K5WgQaIiEdIX9w5lF+xZOM34Llf5o3Ab4vvRxwoLtJjmwn8JbAM+FvSsMEuwMWS5pbM/+fAu4HPkb4Qcz/gR5J2a80g6dnAT4FnAR8D3gfcByyRdMxm4jkI+BXpKHlzlgHPlvQhSftIerqkDwLPAz4xjv423AY5959A0nOKdX6tat8sRMRQPkhv+QN43hjzTAO27mibDdwCfLmtbaRY1v3Anm3tBxXtn2pr+wHp/r/T29oE/Bi4tq1tXtF3Xknb6Di2b3vgHODRok+QnhBHNb3v/Wj2MdVzv2RbTi/6Pqvpfd/Lw0fSY4iIjRHxEICkLSTtSBrHvxI4sKTLkoi4ua3/SmAFcESxjB2BlwDfBGZI2rl4+7YTcDGwr6Q9x4hnWUQoIkbHEf4G4FrS1y29gXSD+CuBf5N08Dj62xAb8Nx/jKQtgNcDV0XEr6r0zYVPHG6GpBNIb8ueCWzVNum3JbOXXd5zLemqCkjfJCHSt2p8qMsqdwVu7jKtis8CBwMHRvGdb5K+CfwSOIPHv7jUrNQA5367FwN7MsAnyl2kxyDpeGAx6VK2T5K+T20jcDLw9B4W2Xrncjrp6KHMhL/+R9LWpO+7+0S0fSlnRDws6SLgXZK2bh0pmXUa1Nwv8SbSkN/X+7DsWrhIj+1Y4HrgNVEMbgFIWthl/n1L2p4BrC5+v774+XBE/GCygiyxE+l/O61k2lakJ0zZNLOWQc39xyh9i/qfAssiYk0d6+wHj0mPbWPxU60GSc8HDuky/9Ht42qSDiINK1wEEBG3kc6Wv1XSkzs7q+Sr6jumj/cypNuAdcAxxVF1q/8OwJ8Av44IX4ZnYxnU3G93BOlk58BdG93OR9LwZkmHl7SfAXwXeA1wvqQLgKcBbwOuYdNPNEF6u3a5pM8D00mffLqTJ17y9k7gcuAXkr5EOsLYjZT8c4ADxoj1IOBSYCHpkqhSEbFR0umkT1j9VNJXSUfOf1Gs4/gx1mHDY8rlfoc3kU6gnzfO+bPkIg1v79K+uHjsDrwVeCUpQY8HjiNdEtTpq6TxrwWkkyArgXdFxNrWDBFxjdI9E04hXQq1E+nI9yrg1IltyuMi4iOSfgu8p1jXdNLlT8dGxEAnrU2aKZn7AJJmAkcCF0TE+slcdt3UNtxkZmaZ8Zi0mVnGXKTNzDLmIm1mljEXaTOzjLlIm5llzEXazCxjLtJmZhlzkTYzy5iLtJlZxlykzcwy5iJtZpYxF2kzs4y5SJuZZcxF2swsYy7SZmYZc5E2M8uYi7SZWcZcpM3MMuYibWaWMRdpM7OMDcy3hUsSsAdwT9OxWKkZwJrwNxtPOud+9vqa+wNTpElJelPTQdiY5gA3Nx3EFOTcz1/fcn+QinRtRxFHHHFE5T5f+MIXKveZNWtW5T7r16+v3Gf//fevZT34SK9fatuvveTKkUceWbnPH/7hH1bus9dee1Xu08tzrJd9QB//R7UWaUnvBP4a2B24GviriFhZZwzjsdVWW1XuM3PmzFr69PKOKr1btiYNSu5Pmzatcp9tttmmcp/tttuucp8ddtihcp8ZM2ZU7pOb2k4cSnod8ClgIXAgKVEvlrRrXTGYNcG5bxNR59UdJwFfiogzI+Ia4G3A/cCba4zBrAnOfetZLUVa0tbAc4EftNoi4tHi70O69JkuaWbrQTqDajZQnPs2UXUdSe8MTANu7Wi/lTRGV+ZkYH3bw2e3bRA5921Ccv4wy2nArLbHnGbDMauNc98eU9fVHXcAG4HdOtp3A24p6xARG4ANrb99hYINKOe+TUgtR9IR8RDwM+ClrTZJWxR/X1FHDGZNcO7bRNV5nfSngLMkXQmsBBYA2wNn1hiDWROc+9az2op0RJwjaRfgVNIJk1XA4RHReULFbEpx7ttEaFDuh1NcilT5s8qLFy+uvK4TTjihcp+lS5dW7rNq1arKfU455ZTKfY4++ujKfXrZHmBWRNzdS0frrtfcHxkZqbyuJUuWVO5zwAEHVO5z9dVXV+5Tl7lz5/bSrW+5n/PVHWZmQ89F2swsYy7SZmYZc5E2M8uYi7SZWcZcpM3MMuYibWaWMRdpM7OMuUibmWXMRdrMLGMu0mZmGXORNjPLWJ23Km1ELzeZOeussyr3WbBgQeU+ixYtqtxn/frK99lh+fLllfvY4Fu3bl3lPr3cLMlfStBfPpI2M8uYi7SZWcZcpM3MMuYibWaWMRdpM7OMuUibmWXMRdrMLGMu0mZmGXORNjPLmIu0mVnGXKTNzDLmIm1mlrEpf4OlefPm1bKe0dHRyn1OOOGEyn2WLl1auY8Np15uLtaLJUuWVO7Ty82fermJWS/ryY2PpM3MMuYibWaWMRdpM7OMuUibmWXMRdrMLGMu0mZmGXORNjPLmIu0mVnGXKTNzDLmIm1mljEXaTOzjLlIm5llbMrfYKkuixYtqtynlxvg9HJTpl5imz9/fuU+Npzmzp1by3qGNY99JG1mljEXaTOzjLlIm5llzEXazCxjLtJmZhlzkTYzy5iLtJlZxlykzcwy5iJtZpYxF2kzs4y5SJuZZcxF2swsY4qIpmMYF0kzgfVNx9FNLzdLWr16deU+CxYsqNzn05/+dOU+kir3AWZFxN29dLTu6sz90dHRyn2WLFlSuU8vNz7q5Tl29NFHV+7To77lvo+kzcwy5iJtZpaxWoq0pFFJ0fH4dR3rNmuSc98mqs6b/v8SeFnb34/UuG6zJjn3rWd1FulHIuKW8c4saTowva1pxuSHZFYL5771rM4x6X0lrZF0vaSzJe21mflPJp3Rbj1u6nuEZv3h3Lee1VWkVwDzgcOBtwNPAy6TNNYRwmnArLbHnD7HaNYPzn2bkFqGOyLiorY/fy5pBXAD8Frgy136bAA2tP7u8bpds0Y5922iGrkELyLWAdcC+zSxfrOmOPetqkaKtKQdgKcDa5tYv1lTnPtWVV3XSZ8u6cWSRiQdCpwPbAS+Xsf6zZri3LeJqusSvDmkpNwJuB24HDg4Im6vaf1mTXHu24TUdeLw9XWsZ7L0cpOZXm7kcsopp1Tu00tsy5cvr9zHJseg5f66desq91m2bFkt61m1alXlPlOB791hZpYxF2kzs4y5SJuZZcxF2swsYy7SZmYZc5E2M8uYi7SZWcZcpM3MMuYibWaWMRdpM7OMuUibmWXMRdrMLGOKiKZjGBdJM0nf99Z3Rx11VOU+Z511VuU+s2bNqtznhhtuqNynl5s/9Xgzm1kRcXcvHa27OnN/ZGSkcp/FixdX7jN79uzKfXrJ49WrV1fu06O+5b6PpM3MMuYibWaWMRdpM7OMuUibmWXMRdrMLGMu0mZmGXORNjPLmIu0mVnGXKTNzDLmIm1mljEXaTOzjG3ZdAA5evjhhyv3ufvu6h/bl1S5zz333FO5z8aNGyv3seH06KOPVu5z3333Ve6z5ZbVS08vsU0Fg3SDpT2Bm5qOw8Y0JyJubjqIqca5PxD6lvuDVKQF7AF0HkrOICXwnJJpwyKHfTADWBODklADxLk/phz2QV9zf2CGO4odsMkrVduQwT3DepvMTPbBUO77Ojj3u8tkH/R1vT5xaGaWMRdpM7OMTYUivQFYWPwcVt4Hw8n/9yHYBwNz4tDMbBhNhSNpM7Mpy0XazCxjLtJmZhlzkTYzy9jAFmlJ0yV9XNIaSQ9IWiHp5U3HVRdJ8yRFl8fBTcdn/ePcH67cH5hPHJZYDBwLLAJ+A8wHLpR0WERc3lxYtfsM8J8dbdc1EYjVZjHOfRiS3B/IS/AkHQSsAP46Ik4v2rYB/hu4LSIObTK+OkiaB1wKHBcR5zYbjdXFuT98uT+owx3HAhuBL7YaIuJB4MvAIZKe0lRgTZA0Q9Igvyuy8XPutxmG3B/UIv0c4NqSG6qsLH7OrTecRp1JusHLg5IulfS8pgOyvnLuP24ocn9QX4GeDKwtaW+17VFjLE15CDgPuBC4A/gD4P3AZZIOjYirmgzO+sa5P2S5P6hFelvKP6v/YNv0KS0ifgL8pK3pO5LOBX4OnAYc3khg1m/O/SHL/UEd7ngAmF7Svk3b9KETEdcBS4HDJE1rOh7rC+d+iamc+4NapNeS3vZ1arWtqTGW3NwIbA1s33Qg1hfO/e6mZO4PapFeBTxD0syO9ue3TR9We5Pe+t7bdCDWF6tw7nczJXN/UIv0ucA04C2tBknTgROBFRFxY1OB1UXSLiVtBwCvBi6JiOH8auWpz7k/ZLk/kCcOI2KFpG8Bp0nalfQpoxOAEeAvmoytRudIeoB0AuU20hnutwD3Ax9oMjDrH+c+MGS5P5CfOITHPmX1IeB44EmkM7sfjIiLGw2sJpLeDbwJ2AeYCdwO/BBYWJxEsSnKuT9cuT+wRdrMbBgM6pi0mdlQcJE2M8uYi7SZWcZcpM3MMuYibWaWMRdpM7OMuUibmWXMRdrMLGMu0mZmGXORngSSRoqvk3//JC6z9bX18yZrmWaTzbnff0NbpCXNLxJhSn4vmqRjJF0saY2kDZJuknSupP2ajs2aNQS5P1psX+fjwc33zs9A3gXPxmV/4C7gDNL3wO0OvBlYKemQiLi6yeDMavB2nnhv6Y1NBTIRLtJTVESc2tkm6V+Bm0jJ+7bagzKr17kRcUfTQUzU0A53jIekrSWdKulnktZLuk/SZZIOG6PPeyXdIOkBScvLhhckPbMYevi9pAclXSnp1eOIZ7ui7849btJtpHvuzu6xvw2JKZL7kjRTkir0yY6L9NhmAn8JLAP+FhgFdgEuljS3ZP4/B94NfI70rcX7AT+StFtrBknPBn4KPAv4GPA+4D5giaRjNhPPQcCvgHeNdwMkzZa0i6T9gX8ttumH4+1vQ2vgcx+4HlgP3CPp39pjGSQe7hjbXcBIRDzUapD0JeDXwF+x6Tdh7APsGxE3F/N+D1hBSvKTinnOAH4H/FFEbCjm+2fgcuDjwPmTvA0/Bf5P8fu9wIeBL0/yOmzqGeTcvwv4LHAFsAF4IfBO4CBJz4uIuydpPbVwkR5DRGykONkgaQvSMMEWwJXAgSVdlrSStOi/UtIK4AjgJEk7Ai8B/gGYIWlGW9+LgYWS9mxfRkc8y4Cqb91OJB0V7V38vi3pO/Km1PfA2eQa5NyPiDM6ms6TtBI4G3gH6Sh+YLhIb4akE0hvy54JbNU26bcls/+mpO1a4LXF7/uQEu1DxaPMrkBpovYiIq5o/S7pG6S3jACTdl2rTU2DnvvtIuJrkv4ReBku0lOHpOOBxcAS4JOkE28bgZOBp/ewyNY5gNNJRw9l+vYdbRFxl6Qfkb4fzkXauppquV+4Edixz+uYdC7SYzuWdPLhNdH2ZZCSFnaZf9+StmcAq4vfry9+PhwRP5isICvaFpjV0LptcEyp3C+u8BgBrqp73RPlqzvG1rr4/bGxMEnPBw7pMv/RkvZsm/cg4PnARQARcRvpbPlbJT25s7OkXcYKpsplSJJ2LWkbAV5KGlc0G8sg537Zst5Oujrle5vrnxsfScObJR1e0n4G8F3gNcD5ki4Ankb6EMg1wA4lfa4DLpf0eWA6sAC4E/hE2zzvJJ3N/kVxtvx6YDdS8s8BDhgj1oOAS4GFpEuixvILST8EVpHOdu9LOiO/FfCBzfS14TBVc/8GSecAvwAeBF4AvJ70XPiXzfTNjot0eoUts7h47A68FXglKUGPB44D5pX0+SrpqokFpJMgK4F3RcTa1gwRcY3SPRNOAeYDO5HG+64CNvmU4AR8HjgSOByYUazjEuCjEfGLSVyPDa6pmvtnA4cCfwpsA9xAerH4SETcP4nrqYXahpvMzCwzHpM2M8uYi7SZWcZcpM3MMuYibWaWMRdpM7OMuUibmWXMRdrMLGMu0mZmGXORNjPLmIu0mVnGXKTNzDLmIm1mlrH/D/U2c+VLbCTSAAAAAElFTkSuQmCC", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": { "needs_background": "light" @@ -208,7 +172,17 @@ "output_type": "display_data" } ], - "execution_count": 6 + "source": [ + "# Visualize some of the data\n", + "fig, axes = plt.subplots(2, 2, figsize=(4, 4))\n", + "for i in range(4):\n", + " ax = axes[i % 2, i // 2]\n", + " ax.imshow(np.reshape(training_data[0][i], (8, 8)), cmap=\"grey\")\n", + " ax.set_xlabel(f\"Label: {training_data[1][i]}\")\n", + "plt.suptitle(\"Example images from the dataset\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] }, { "cell_type": "markdown", @@ -219,17 +193,12 @@ }, { "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2024-04-04T12:53:43.224251Z", - "start_time": "2024-04-04T12:53:43.222074Z" - } - }, + "execution_count": 7, + "metadata": {}, + "outputs": [], "source": [ "dataset = Dataset(*training_data, *test_data)" - ], - "outputs": [], - "execution_count": 7 + ] }, { "cell_type": "markdown", @@ -248,12 +217,18 @@ }, { "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2024-04-04T12:53:44.248491Z", - "start_time": "2024-04-04T12:53:43.224805Z" + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Accuracy: 0.530\n", + "Test Accuracy: 0.435\n" + ] } - }, + ], "source": [ "import torch\n", "from torch import nn, optim\n", @@ -323,27 +298,24 @@ "model.fit(x=training_data[0], y=training_data[1])\n", "print(f\"Train Accuracy: {model.score(x=training_data[0], y=training_data[1]):.3f}\")\n", "print(f\"Test Accuracy: {model.score(x=test_data[0], y=test_data[1]):.3f}\")" - ], + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Train Accuracy: 0.530\n", - "Test Accuracy: 0.435\n" + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00\n", "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
data_valuedata_value_stderr
39-0.8695270.042223
130-0.8634770.004781
66-0.8329240.000774
153-0.6042380.037897
32-0.5700900.182911
\n", - "" - ], - "text/plain": [ - " data_value data_value_stderr\n", - "39 -0.869527 0.042223\n", - "130 -0.863477 0.004781\n", - "66 -0.832924 0.000774\n", - "153 -0.604238 0.037897\n", - "32 -0.570090 0.182911" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "df.head()" ] @@ -424,7 +323,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -435,20 +334,7 @@ "invertible-output" ] }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "low_dvl = df.iloc[:30].copy()\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -475,7 +361,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -486,27 +372,7 @@ "invertible-output" ] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Average value of first 10 data points: 0.4317312540895265\n", - "Exact values:\n", - "49 0.307256\n", - "120 0.320427\n", - "80 0.322495\n", - "102 0.344323\n", - "62 0.392833\n", - "5 0.397684\n", - "115 0.438929\n", - "76 0.496701\n", - "71 0.636801\n", - "9 0.659862\n", - "Name: data_value, dtype: float64\n" - ] - } - ], + "outputs": [], "source": [ "high_dvl = df.iloc[-10:].copy()\n", "print(f\"Average value of first 10 data points: {high_dvl['data_value'].mean()}\")\n", @@ -522,22 +388,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "x_train_anomalous = training_data[0].copy()\n", "y_train_anomalous = training_data[1].copy()\n", @@ -567,20 +420,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - " 0%| | 0/100 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from scipy.stats import norm\n", "\n", @@ -683,26 +512,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Average value of original data points: 0.4317312540895265\n", - "Average value of modified, anomalous data points: -0.039424471827874424\n", - "For reference, these are the average data values of all data points used for training (anomalous):\n", - "data_value -0.009905\n", - "data_value_stderr 0.112510\n", - "dtype: float64\n", - "These are the average data values of all points (original data):\n", - "data_value -0.011644\n", - "data_value_stderr 0.104547\n", - "dtype: float64\n" - ] - } - ], + "outputs": [], "source": [ "print(\n", " f\"Average value of original data points: {plot_data['original_data_value'].mean()}\"\n", @@ -731,21 +543,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/100 [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
data_valuedata_value_stderr
176-0.0642110.027643
61-0.0552450.027234
36-0.0503180.026853
44-0.0465960.027569
159-0.0421540.026803
\n", - "" - ], - "text/plain": [ - " data_value data_value_stderr\n", - "176 -0.064211 0.027643\n", - "61 -0.055245 0.027234\n", - "36 -0.050318 0.026853\n", - "44 -0.046596 0.027569\n", - "159 -0.042154 0.026803" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "msr_df.head()" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "high_dvl = df.iloc[-30:]\n", "high_dvl.index = high_dvl.index.map(str)\n", @@ -873,22 +591,9 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "low_dvl = df.iloc[:30]\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -912,13 +617,13 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "if is_CI:\n", - " max_checks = 10\n", - " moving_avg = 10\n", + " max_checks = 1\n", + " moving_avg = 1\n", "else:\n", " max_checks = 10000\n", " moving_avg = 200" @@ -926,154 +631,94 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - " 0%| | 0/100 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Compare convergence speed of both methods\n", "import numpy as np\n", @@ -1121,29 +766,155 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The plot above visualizes the convergence speed of different samplers used for Banzhaf semivalue calculation. It shows the average magnitude of how much the semivalues are updated in every step of the algorithm. As you can see, MSR Banzhaf converges much faster. After 1000 iterations (subsets tried), Monte Carlo Banzhaf has evaluated the marginal function about 5 times per data point. For maximum sample reuse, the semivalue of each data point was updated 1000 times. Due to this, the values converge much quicker." + "The plot above visualizes the convergence speed of different samplers used for Banzhaf semivalue calculation. \n", + "It shows the average magnitude of how much the semivalues are updated in every step of the algorithm. \n", + "\n", + "As you can see, **MSR Banzhaf** converges much faster. \n", + "After 1000 iterations (subsets tried), Monte Carlo Banzhaf has evaluated the marginal function about 5 times per data point (we are using 200 data points). \n", + "For maximum sample reuse, the semivalue of each data point was updated 1000 times. Due to this, the values converge much quicker, which is one of the advantages of MSR sampling. \n", + "\n", + "MSR sampling does come at a cost, however, which we will visualize in the next plot. The semivalues that MSR converges to are less consistent." ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.951534782455586\n", - "SignificanceResult(statistic=0.1615150378759469, pvalue=0.02232027439671079)\n" - ] - } - ], + "outputs": [], "source": [ "from scipy.stats import spearmanr\n", "\n", - "print(np.linalg.norm(permutation_values.values - msr_values.values))\n", + "print(\"Similarity of the ranking of Permutation Sampler and MSR Sampler semivalues:\")\n", "print(spearmanr(permutation_values.values, msr_values.values))" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Consistency of the semivalues\n", + "\n", + "In this part, we want to analyze how consistent the semivalues returned by the different samplers are. \n", + "To evaluate this, we will compute semivalues multiple times and check how many of the data points in the top and lowest 20% of valuation of the data overlap." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "max_checks = [1e3, 2e3, 3e3] if not is_CI else [1, 2]\n", + "num_retries = 3 if not is_CI else 2\n", + "num_samplers = 5\n", + "twenty_percent = training_data[0].shape[0] // 5\n", + "if is_CI:\n", + " exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run all experiments\n", + "from tqdm import tqdm\n", + "\n", + "\n", + "results = [[[] for i in range(num_samplers)] for _ in max_checks]\n", + "pbar = tqdm(total=len(max_checks) * num_retries * 5)\n", + "for check_index, max_check in enumerate(max_checks):\n", + " for retry in range(num_retries):\n", + " for sampler_index, sampler in enumerate(\n", + " [\n", + " PermutationSampler,\n", + " MSRSampler,\n", + " UniformSampler,\n", + " AntitheticSampler,\n", + " RandomHierarchicalSampler,\n", + " ]\n", + " ):\n", + " _, vals = get_semivalues_and_history(sampler, num_checks=max_check)\n", + " results[check_index][sampler_index].append(vals)\n", + " pbar.n = (\n", + " check_index * (num_samplers * num_retries)\n", + " + retry * num_samplers\n", + " + sampler_index\n", + " + 1\n", + " )\n", + " pbar.refresh()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Extract results from experiments\n", + "\n", + "plot_results_top = [[] for _ in range(num_samplers)]\n", + "plot_results_low = [[] for _ in range(num_samplers)]\n", + "for check_index, _ in enumerate(max_checks):\n", + " for sampler_index, sampler in enumerate(\n", + " [\n", + " PermutationSampler,\n", + " MSRSampler,\n", + " UniformSampler,\n", + " AntitheticSampler,\n", + " RandomHierarchicalSampler,\n", + " ]\n", + " ):\n", + " value_list = results[check_index][sampler_index]\n", + " top_20 = None\n", + " lower_20 = None\n", + " for vals in value_list:\n", + " vals.sort(key=\"value\")\n", + " if top_20 is None:\n", + " top_20 = set(vals.indices[-twenty_percent:].tolist())\n", + " lower_20 = set(vals.indices[:twenty_percent].tolist())\n", + " else:\n", + " top_20 = top_20.intersection(\n", + " set(vals.indices[-twenty_percent:].tolist())\n", + " )\n", + " lower_20 = lower_20.intersection(\n", + " set(vals.indices[:twenty_percent].tolist())\n", + " )\n", + " plot_results_top[sampler_index].append(len(top_20))\n", + " plot_results_low[sampler_index].append(len(lower_20))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot results\n", + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(8, 8))\n", + "for sampler_index, name in enumerate(names):\n", + " axes[0].plot(max_checks, plot_results_top[sampler_index], label=name)\n", + " axes[1].plot(max_checks, plot_results_low[sampler_index], label=name)\n", + "axes[0].legend()\n", + "axes[1].legend()\n", + "axes[0].set_xlabel(\"Number of iterations\")\n", + "axes[1].set_xlabel(\"Number of iterations\")\n", + "axes[0].set_ylabel(f\"Number of common points \\nin top 20% in {num_retries} runs\")\n", + "axes[1].set_ylabel(f\"Number of common points \\nin lower 20% in {num_retries} runs\")\n", + "fig.suptitle(f\"Evaluation of consistency of samplers (Max value: {twenty_percent})\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Conclusion:**\n", + "MSR" + ] } ], "metadata": { diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 2fc186813..1aed0979a 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -77,6 +77,7 @@ "AntitheticSampler", "DeterministicUniformSampler", "DeterministicPermutationSampler", + "MSRSampler", "PermutationSampler", "PowersetSampler", "RandomHierarchicalSampler", From be76dc5a6db5525074315bd4c753431970675d18 Mon Sep 17 00:00:00 2001 From: jakob1111996 Date: Fri, 5 Apr 2024 16:50:39 +0200 Subject: [PATCH 27/42] speedup test in ci by using another utility --- .notebook_test_durations | 19 +- notebooks/msr_banzhaf_digits.ipynb | 2497 +++++++++++++++++++++++++++- 2 files changed, 2439 insertions(+), 77 deletions(-) diff --git a/.notebook_test_durations b/.notebook_test_durations index 1d87378ae..8fd388a2f 100644 --- a/.notebook_test_durations +++ b/.notebook_test_durations @@ -1,11 +1,12 @@ { - "notebooks/data_oob.ipynb::": 14.608769827000287, - "notebooks/influence_imagenet.ipynb::": 13.570316236000508, - "notebooks/influence_sentiment_analysis.ipynb::": 20.546479973001624, - "notebooks/influence_synthetic.ipynb::": 5.9324631089984905, - "notebooks/influence_wine.ipynb::": 16.114133220999065, - "notebooks/least_core_basic.ipynb::": 14.312467472000208, - "notebooks/shapley_basic_spotify.ipynb::": 15.608795123000164, - "notebooks/shapley_knn_flowers.ipynb::": 3.9430189769991557, - "notebooks/shapley_utility_learning.ipynb::": 26.96671833400069 + "notebooks/data_oob.ipynb::": 14.514983271001256, + "notebooks/influence_imagenet.ipynb::": 15.937124550999215, + "notebooks/influence_sentiment_analysis.ipynb::": 26.479645616000198, + "notebooks/influence_synthetic.ipynb::": 6.61773010700017, + "notebooks/influence_wine.ipynb::": 16.312171267998565, + "notebooks/least_core_basic.ipynb::": 14.375480750999486, + "notebooks/msr_banzhaf_digits.ipynb::": 106.6507187110019, + "notebooks/shapley_basic_spotify.ipynb::": 15.657225806997303, + "notebooks/shapley_knn_flowers.ipynb::": 3.9943819290019746, + "notebooks/shapley_utility_learning.ipynb::": 25.939783253001224 } \ No newline at end of file diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb index 2b9f64e38..a22d17dbb 100644 --- a/notebooks/msr_banzhaf_digits.ipynb +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "tags": [ "hide" @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "tags": [ "hide" @@ -79,8 +79,7 @@ "is_CI = os.environ.get(\"CI\")\n", "random_state = 24\n", "n_jobs = 16\n", - "random.seed(random_state)\n", - "is_CI = True" + "random.seed(random_state)" ] }, { @@ -93,9 +92,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jakob/Documents/pyDVL/src/pydvl/parallel/config.py:31: FutureWarning: The `ParallelConfig` class was deprecated in v0.9.0 and will be removed in v0.10.0\n", + " warnings.warn(\n", + "/home/jakob/Documents/pyDVL/src/pydvl/parallel/config.py:31: FutureWarning: The `ParallelConfig` class was deprecated in v0.9.0 and will be removed in v0.10.0\n", + " warnings.warn(\n" + ] + } + ], "source": [ "%autoreload\n", "from pydvl.reporting.plots import plot_shapley\n", @@ -114,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "editable": true, "slideshow": { @@ -131,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "editable": true, "slideshow": { @@ -157,9 +167,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Visualize some of the data\n", "fig, axes = plt.subplots(2, 2, figsize=(4, 4))\n", @@ -181,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -205,9 +228,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Accuracy: 0.300\n", + "Test Accuracy: 0.081\n" + ] + } + ], "source": [ "import torch\n", "from torch import nn, optim\n", @@ -281,9 +313,84 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
data_valuedata_value_stderr
00.00.0
10.00.0
30.00.0
40.00.0
50.00.0
\n", + "" + ], + "text/plain": [ + " data_value data_value_stderr\n", + "0 0.0 0.0\n", + "1 0.0 0.0\n", + "3 0.0 0.0\n", + "4 0.0 0.0\n", + "5 0.0 0.0" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "df.head()" ] @@ -323,7 +499,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "editable": true, "slideshow": { @@ -334,7 +510,20 @@ "invertible-output" ] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "low_dvl = df.iloc[:30].copy()\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -361,7 +550,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "editable": true, "slideshow": { @@ -372,7 +561,27 @@ "invertible-output" ] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average value of first 10 data points: 0.00015914351851851853\n", + "Exact values:\n", + "0 0.000000\n", + "1 0.000000\n", + "3 0.000000\n", + "4 0.000000\n", + "5 0.000000\n", + "6 0.000000\n", + "7 0.000000\n", + "8 0.000000\n", + "9 0.000000\n", + "2 0.001591\n", + "Name: data_value, dtype: float64\n" + ] + } + ], "source": [ "high_dvl = df.iloc[-10:].copy()\n", "print(f\"Average value of first 10 data points: {high_dvl['data_value'].mean()}\")\n", @@ -388,9 +597,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "x_train_anomalous = training_data[0].copy()\n", "y_train_anomalous = training_data[1].copy()\n", @@ -420,9 +642,84 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "from scipy.stats import norm\n", "\n", @@ -512,9 +822,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average value of original data points: 0.00015914351851851853\n", + "Average value of modified, anomalous data points: 0.0\n", + "For reference, these are the average data values of all data points used for training (anomalous):\n", + "data_value 0.0\n", + "data_value_stderr 0.0\n", + "dtype: float64\n", + "These are the average data values of all points (original data):\n", + "data_value 0.000159\n", + "data_value_stderr 0.000000\n", + "dtype: float64\n" + ] + } + ], "source": [ "print(\n", " f\"Average value of original data points: {plot_data['original_data_value'].mean()}\"\n", @@ -543,9 +870,87 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/100 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
data_valuedata_value_stderr
5-0.0232790.011563
2-0.0177080.011823
7-0.0098150.013890
4-0.0030980.013650
8-0.0012960.012168
\n", + "" + ], + "text/plain": [ + " data_value data_value_stderr\n", + "5 -0.023279 0.011563\n", + "2 -0.017708 0.011823\n", + "7 -0.009815 0.013890\n", + "4 -0.003098 0.013650\n", + "8 -0.001296 0.012168" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "msr_df.head()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABnMAAAIsCAYAAAApsVyuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABWF0lEQVR4nO3de5xuZV03/s8XUCyEjXhgp0RgWR7zgMqDpalkmqKZaR5LslJSH/TJNElLxRNPj5KH/Fn4eKJQME30AZPEA2bi9pAongpNDOTgEfAECHx/f6w1eTPO7D0ze++ZtWe/36/X/Zq517rWtb73zNqzZ9bnvq6rujsAAAAAAABM0y5rXQAAAAAAAACLE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAsoKrOrapzl3nMc6uqq+qe2+D8h499Hb6MY94wHnPAap97LY21fmCt6wAAgO1FmAMAABM13qDuta6DH9nRQg4AAGB9EOYAAAAs7NDxsSM5Ksmtknx1rQsBAAC2nd3WugAAAIAp6u4vrXUNy9XdFya5cK3rAAAAti0jcwAAYAdSVQeM03y9oap+tqreWlXfrKrvVNU/V9Vtx3Y3rqrjqurCqrq8qj5WVfdaoL+bVtVfVNW/VtVFVXVlVV1QVW+qqlsvUkNV1VOq6nNj31+tqr+uqg2bW2emqh5ZVe+vqkvG4z5fVc+uqt0XaHv3qvp/VXV+VV0x1vaRqnrOEr5GvzB+jU6Yt/3Auanrquru8/b973H7vWe2Xeu1jGuyvH58+vqZvhZco6aqHlpVH62q71fVt6rqxKq62ZbqX+Q13auqPjB+ny+rqlOr6lYLtFtwzZyVfs+Wc+5Fjn3EWM9fLbJ/96r69nid7jZu21BVT6+q943f/yur6utV9c6qOmQp593c12Lcd89x33MX2LdPVb14vD5/UFWXVtV7q+rXFmh73ao6sqr+bXwd3x+/nu+oql9daq0AALAlRuYAAMCO6YAkm5J8Pskbxue/meQD4w3vdye5LMlJSfZJ8ogk/1RVP9/d/zXTzz2SPDPJ+5O8Lcl3k9wiyUOTPKiqfqm7PzXv3K9K8kdJLkhyXJIrkzwoyV2TXCfJD+cXW1WvS/J7Sc4fz3NJkv+R5PlJDq2q+3T3VWPb+yU5daz/nRmmDNsnw/RhT0zyvM19Ybr736vqq0nuPW/XofM+/5d5zy9P8uHNdP2Gse7fSPKOJGfN7LtkXtsnZviavDPJGUkOTvLwJLevqjt09xWbew3zHDae85+S/E2SWye5f5K7VNWtu/sbS+hj2d+zbXTuk5NcmuRRVfX0ue/xjN9IsneSl87su1WSFyb5YIbr4NtJ9h/r/fWqemB3v3sJr3nZqupnknwgw7+nf8nw72iPDF+Hd1fVE7r7NTOHvCHJI5N8JsnxSX6Q5KZJfjnJ/ZKcvj3qBABg5yPMAQCAHdOvJHl2d79wbkNV/XmSozOEPG9J8sTuvmbc954MN5v/1/iY874k+3b3d2Y7r6rbJ/nXJMck+fWZ7XfPEAr8R5KDu/uScfufZbhxfdMkX5nX1+EZgpy3J3l0d/9gZt9zkzwnyZOSvHzc/IcZZhG45/wgqaputISvzdzr+p2quk13f3bcdmiSb2QIlA5N8tyxzxskuWOSD3T35Yt12N1vqKpkCCBO7u43bOb890tyl+4+e6b2N2W48f8bGb4/S/XgJPft7vfO9PXiDCHc45L85eYOXsn3bFudu7svr6qTkjw+w9fklHlNHjt+fOPMts8nuen8oKiq9kvy0SR/lSFk2R7emORnkjyyu0+cOffeGUKeV1TVO7v74qrakCEk/USGr+vV8+q94XaqEQCAnZBp1gAAYMd0boagZdbcDfHdkzx9LsgZvSnJVUnuMHtAd39tfpAzbv9UhkDkXlV1nZldczffXzgXCoztr0xy1CK1PmU89+Nmg5zR85N8M8mjFzhuftsscRRKksyFD7Ojce6d4TWdnuTgqtpj3H6vDH8bvTfbzitmg5zR3IiOuy6zrxNnw5TRccvoayXfs2117uRH1+VjZzdW1cYk903yydmvVXdfutD3ubvPT/LWJLesqv2XeO4lGwPMX0nyttkgZzz3JRlCx+sl+a25zUkqyRVJZv+tzR3zzW1dIwAAOy8jcwAAYMd01vyRABmm0EqS/5gf0HT31VV1cZL95ndUVQ9IckSSOye5UX7874QbJblw/PyO48cPLVDTRzKENrN9/2SS22cYEfPUcWTLfFdkmFprzglJHpJk0ziq4/1J/nW8mb9U7xs/HpphNMVtk9wkQ2BzXpI/yTDF3D/lR9OxvW9+J1vh4wtsO2/8eINV7mtZ37NtfO5094er6j+SPLCqbtDd3x53PTrJrhmmKruWqvqlDCHgIRm+b9ed1+RmSf5r/nFbaW49ng0LraWT5Mbjx1slSXdfVlX/L8kDk5xVVW/LMDXbpu7+/jauDQCAnZwwBwAAdkyXzt/Q3VeNYcmP7RtdlWF9lP9WVU9J8rIM65K8J8MN8u9nGHXw4AxBzO4zh2wYP168wPmvrqr5oxFukGH0wo0zjGzYou7+x6o6LMnTMkzl9YSx1k8kOaq737OEPs6rqnOS/EpV7ZofjdB5b5KLMqwRc2iGMOfQDOvzfGwp9S3RJQtsmwtNdt3avma+10vpa7nfs2157jlvzLAOziOSvHrc9tgM34c3zTasqt/MMALn8gzX5JeSfC/D6Jd7Zhg9M3tNbitz06LdZ3ws5voznz88yZ8meVR+tJbT5VX11iR/0t0/9jUHAICVEOYAAMBOqqp2y7BuzEVJ7tTdF87bf8gCh102ftw3yX/Oa79rhhviX53ZPBcsfbK777TU2rr71CSnjlOhHZxhAfo/SnJKVd2xuz+3hG7elyEIukuGwOYr3f2lsdaPJvnVqrppklsmOWWBkU7rxXK/Z9vD32WYUu+xSV5dVXdMcrsk71hgSrXnJ7kyyZ27+/Pz6v3bDGHOUsxNfbbQ3717L7Bt7lp9Sne/YiknGKcNfG6S51bVT2cY7XV4ksckOSDJ3ZdYKwAAbJY1cwAAYOd1oww3tT+8QJBz/SQLhS+fHD/+8gL7/kfm3Tjv7u8m+WyS21TVPsstsLu/193v6+4/TvKiDNNt/foSD59b6+W+GW6yv3fevl/MMLIiWfp6OXOBz3JH16ylZX3PtofuPi9DuHZwVf1CfrR+zhsXaP5zST63QJCzSxZ+DYuZm87tpxfYd+cFtn1k/LiiAKa7z+vuEzJcb19M8stVdcMtHAYAAEsizAEAgJ3X1zJMqXbQGN4kSarqOkleniHsme/48eOzqmrDzDHXzRC2LOTYDCHM66pq7/k7q+oGVXWnmef3GEcNzbfv+HGp65G8P8N0cU/MMNXYbGDzvgzTvz1z5vlSzE1Jtv8S20/BSr5n28Mbxo+/n+SRGdZROmWBducmucU4aipJUsO8bs9NcutlnO+j48c/nN1YVbfLsB7PtXT3xzOsefOQqnrcQh1W1e2q6ibj5zce+5pvjwxTsV2VYYQRAABsNdOsAQDATqq7r6mqV2QINM6uqndkCF3ulWSfDGHIveYdc0ZVHZfk8Uk+Oy76/sMMi8BfmuSC/Gh6q7ljXldVB2UIVb5UVadlWJtnnyQHZhg18/okR4yHvCLJzarqXzPc2L8yyUFJ7p3kK0lOXOLr+0ZVfTrDuj/JtQObMzOEQjdJ8vUkZy+lz5njnjqOurho3P7K7l5sraI1tZLv2Xby9gxTvj01w9pNr+zuHy7Q7q+S/E2ST87U+ksZgpz/l6HupXhHknOSPLKq9kuyKUMI9xvjvt9e4JhHZbhOXltVR47HXJJkvwwjuW6b5JAMQejNxhrPTvLpJOcl2SvDlIAbk7yiu7+zxFoBAGCzjMwBAICd258neVqSH2RYX+YhST6e5K4ZApeF/FGSP07y3QwBzKOSnJ5h0fi98qM1Wv5bdz8pw034M5P86nj8gzKMmPk/SV420/xFY3+3SfIH4zn2Hbffpbu/naWbG43zue6eC17S3Vcm+dD49P3d3UvpbDz3byX5XIa1UZ4/Pm6wjJrWwrK/Z9tad38/yT9kCHKShadYS3f/bZLfS3JhhunYHp0hKDk4yb8t43yXZ1gr6S0ZQpgnJ7l5htf+6kWOOT9DcPisDFPqPTrJkUnuluHfwxPyo+Dv3CTPyTDC6F4Zvr4PSfLl8RxPXWqtAACwJbXEv1kAAAA2q6pukeQ/kpzY3Y9c63rYMt8zAADYMRiZAwAALEtVbRwXo5/d9pP50eiat696UWyW7xkAAOzYrJkDAAAs11MzrEPygQxTYW3MMJ3Vfkn+KcNUWkzLU+N7BgAAOyxhDgAAsFzvSXL7JL+WZJ8kV2WYqusVSV621PVnWFW+ZwAAsAOzZg4AAAAAAMCEWTMHAAAAAABgwoQ5AAAAAAAAE2bNnFVUVZXkpkm+s9a1AAAAAAAAk7Bnkgs2t5alMGd13TTJ+WtdBAAAAAAAMCn7JfnqYjuFOatrbkTOfjE6BwAAAAAAdnZ7ZhgEstnMQJizNr7T3ZetdREAAAAAAMDaGVZn2bJdtnMdAAAAAAAAbAVhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhkwtzqupJVXVuVV1eVZuq6q5baP+wqvrC2P7sqrr/vP1VVUdX1YVV9YOqOr2qbjGvzbOq6sNV9f2qumQz5zq8qj49nutrVfWqrXqxAAAAAAAAW7DbWhcwq6oenuTYJEck2ZTkqUlOq6pf6O6vLdD+bknenOSoJKckeVSSk6vqTt39mbHZM5IcmeSxSb6c5Pljn7fu7svHNtdN8g9Jzkzy+4vU9sdJnpbk6WNteyQ5YCtfMgAAAAAArFsHPPPUXZPcPclPJbkwyb+ce8wDrl7bqnY81d1rXcN/q6pNST7W3U8en++S5Lwkr+zuYxZof1KSPbr7sJltH0lyVncfUVWV5IIkL+3ul4z7NyS5OMnh3X3ivP4OT/Ky7t573vYbJPlqkgd293uX8Xp2T7L7zKY9k5yfZEN3X7bUfgAAAAAAYEdzwDNPfUiSlyfZb2bz+Umecu4xD/jHtalqWqpqrySXZgu5wWSmWauq6yY5KMnpc9u6+5rx+SGLHHbIbPvRaTPtD0yycV6fl2YYWbNYnwu5T4av1c2q6vNVdX5VvaWqfnoLxx2V4Zsw9zh/GecEAAAAAIAd0hjkvDXJzebtulmSt477WaLJhDlJbpRk1wyjZmZdnCGQWcjGLbTfOLNtqX0u5OYZvlZ/lmHqt4cm2SfJe8YQajEvTrJh5rHfZtoCAAAAAMAOb5xa7eXj05q3e+75y8Z2LMGk1syZsF2SXCfJkd39z0lSVY9MclGSe2UYDfRjuvuKJFfMPR9mfQMAAAAAgPXlgGeeevsktxmf3iqbH9xQSX46yXMPeOapnx+3ffbcYx7wqe1Y4g5tSmHON5JcnWTfedv3zRCaLOSiLbS/aGbbhfPanLWM2uaO/dzchu7+elV9I8n+y+gHAAAAAADWo5cn+ZVlHvPsmc/PSHLPbVbNOjOZada6+8okn0hy6Ny2qtplfH7mIoedOdt+dJ+Z9l/OEOjM9rlXkoM30+dC/nX8+Asz/eyTYWq4ryyjHwAAAAAAWI+ekuTR4+MFSzzmBTPHPGU71bUuVHevdQ3/raoenuSNSZ6Q5KMZ1qf57SS37O6Lq+r4JF/t7qPG9nfLkNY9M8mpSR6RYV2bO3X3Z8Y2fzruf2yGcOf5SX4xya27+/Kxzf4Z1sB5UJKnJ7n7WNIXu/u7Y5uTk/xckscnuSzDejg3T3KH7v7hEl/fXkkuTbKhuy9b/lcIAAAAAACmbVwL59wkN8uPr5mTJJ3k/CQHnnvMA65exdImZ6m5wWRG5iRJd5+U5E+SHJ1hGrQ7JLlfd188Ntk/yU/NtP9wkkdlCFg+leShSR48F+SM/jLJK5Mcl+RjSa4/9nn5TJujk3wyyfPG/Z8cH3eeafO7STZlCI3OSPLDsZ8lBTkAAAAAALAzGAOauZE280eUzD1/6s4e5CzHpEbmrHdG5gAAAAAAsLM44JmnPiTDWjr7zWw+L0OQ849rU9W0LDU3EOasImEOAAAAAAA7k3HKtbtnmHXrwiT/YkTOjwhzJkiYAwAAAAAAzNkh18wBAAAAAADg2oQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJm2SYU1VPqqpzq+ryqtpUVXfdQvuHVdUXxvZnV9X95+2vqjq6qi6sqh9U1elVdYt5bZ5VVR+uqu9X1SVbON8Nq+r8quqq2nulrxMAAAAAAGBLJhfmVNXDkxyb5HlJ7pTkU0lOq6qbLNL+bknenOS1Se6Y5OQkJ1fVbWeaPSPJkUmOSHJwku+NfV5vps11k/xDklcvoczXJvn00l8VAAAAAADAylR3r3UN11JVm5J8rLufPD7fJcl5SV7Z3ccs0P6kJHt092Ez2z6S5KzuPqKqKskFSV7a3S8Z929IcnGSw7v7xHn9HZ7kZd299yL1/VGShyc5Osl7k9yguy9Z4mvbK8mlSTZ092VLOQYAAAAAAFiflpobTGpkTlVdN8lBSU6f29bd14zPD1nksENm249Om2l/YJKN8/q8NMmmzfS5WH23TvIXSX43yTVLaL97Ve0190iy53LOBwAAAAAAMKkwJ8mNkuyaYdTMrIszBDIL2biF9htnti21zx9TVbtnmM7t6d39X0s87KgMidrc4/ylng8AAAAAACCZXpgzZS9O8vnu/vtlHrNh5rHf9igMAAAAAABYv6YW5nwjydVJ9p23fd8kFy1yzEVbaH/RzLal9rmQeyd5WFVdVVVXZVgvJ0m+UVXPW+iA7r6iuy+beyT5zjLOBwAAAAAAMK0wp7uvTPKJJIfObauqXcbnZy5y2Jmz7Uf3mWn/5QyhzWyfeyU5eDN9LuS3ktw+yR3Gxx+M2++e5FXL6AcAAAAAAGDJdlvrAhZwbJI3VtXHk3w0yVOT7JHk9UlSVccn+Wp3HzW2f3mSM6rqaUlOTfKIJHdO8vgk6e6uqpcleXZVnZMh3Hl+kguSnDx30qraP8k+SfZPsmtV3WHc9cXu/m53f2m2yKq60fjp57v7km302gEAAAAAAK5lcmFOd59UVTdOcnSSjUnOSnK/7r54bLJ/kmtm2n+4qh6V5AVJXpTknCQP7u7PzHT7lxkCoeOS7J3kQ2Ofl8+0OTrJY2eef3L8eK8kH9gWrw0AAAAAAGC5qrvXuoadxji926VJNoxr6AAAAAAAADuppeYGk1ozBwAAAAAAgGsT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEzYJMOcqnpSVZ1bVZdX1aaquusW2j+sqr4wtj+7qu4/b39V1dFVdWFV/aCqTq+qW8xr86yq+nBVfb+qLlngHLevqjdX1XljH5+vqqdskxcMAAAAAACwiMmFOVX18CTHJnlekjsl+VSS06rqJou0v1uSNyd5bZI7Jjk5yclVdduZZs9IcmSSI5IcnOR7Y5/Xm2lz3ST/kOTVi5R2UJKvJXlMktskeWGSF1fVk5f/KgEAAAAAAJamunuta7iWqtqU5GPd/eTx+S5Jzkvyyu4+ZoH2JyXZo7sPm9n2kSRndfcRVVVJLkjy0u5+ybh/Q5KLkxze3SfO6+/wJC/r7r2XUOurktyqu++9xNe2V5JLk2zo7suWcgwAAAAAALA+LTU3mNTInKq6boYRMKfPbevua8bnhyxy2CGz7UenzbQ/MMnGeX1emmTTZvpcqg1JvrXYzqravar2mnsk2XMrzwcAAAAAAOxkJhXmJLlRkl0zjJqZdXGGQGYhG7fQfuPMtqX2uUXj9G4PT3LcZpodlSFRm3ucv9LzAQAAAAAAO6ephTk7hHE9nnckeV53//Nmmr44w+iducd+q1AeAAAAAACwjuy21gXM840kVyfZd972fZNctMgxF22h/UUz2y6c1+as5RZYVbdO8t4kx3X3CzbXtruvSHLFzLHLPR0AAAAAALCTm9TInO6+Msknkhw6t62qdhmfn7nIYWfOth/dZ6b9lzMEOrN97pXk4M30uaCquk2S9yd5Y3c/aznHAgAAAAAArMTURuYkybFJ3lhVH0/y0SRPTbJHktcnSVUdn+Sr3X3U2P7lSc6oqqclOTXJI5LcOcnjk6S7u6peluTZVXVOhnDn+UkuSHLy3Emrav8k+yTZP8muVXWHcdcXu/u749Rq70tyWpJjq2puvZ2ru/vr2/hrAAAAAAAAkGSCYU53n1RVN05ydJKNGaZCu193Xzw22T/JNTPtP1xVj0rygiQvSnJOkgd392dmuv3LDIHQcUn2TvKhsc/LZ9ocneSxM88/OX68V5IPJHlokhsnecz4mPOVJAes6MUCAAAAAABsQXX3Wtew0xind7s0yYbuvmyt6wEAAAAAANbOUnODSa2ZAwAAAAAAwLUJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZsq8Ocqvqpqrp9Ve2xLQoa+3xSVZ1bVZdX1aaquusW2j+sqr4wtj+7qu4/b39V1dFVdWFV/aCqTq+qW8xr86yq+nBVfb+qLlnkPPtX1aljm69V1f+pqt22+gUDAAAAAAAsYsVhTlX9RlV9Icn5Sf4tycHj9htV1Ser6sEr7PfhSY5N8rwkd0ryqSSnVdVNFml/tyRvTvLaJHdMcnKSk6vqtjPNnpHkyCRHjHV+b+zzejNtrpvkH5K8epHz7Jrk1LHd3ZI8NsnhSY5ewcsEAAAAAABYkuru5R9U9cAMocmZSf45yXOT/Gp3v2/cf0qSq7v7N1bQ96YkH+vuJ4/Pd0lyXpJXdvcxC7Q/Kcke3X3YzLaPJDmru4+oqkpyQZKXdvdLxv0bklyc5PDuPnFef4cneVl37z1v+68nOSXJTbv74nHbEUn+d5Ibd/eVS3hteyW5NMmG7r5sKV8PAAAAAABgfVpqbrDSkTl/keSD3f3LSV61wP4zM4ySWZaqum6Sg5KcPretu68Znx+yyGGHzLYfnTbT/sAkG+f1eWmSTZvpc7HznD0X5MycZ68kt1nogKravar2mnsk2XMZ5wMAAAAAAFhxmHPbJG/ZzP6Lkyw4LdoW3CjJruPx8/vbuMgxG7fQfuPMtqX2uZzzzJ5jvqMyJGpzj/OXcT4AAAAAAIAVhznfT7LHZvbfPMk3V9j3evLiJBtmHvutbTkAAAAAAMCOZqVhzvuTPLaqdpu/o6o2JvnDDGvpLNc3klydZN952/dNctEix1y0hfYXzWxbap/LOc/sOa6lu6/o7svmHkm+s4zzAQAAAAAArDjMeVaGUSYfS/KEJJ3kvlX1giRnJ6kkz1tup919ZZJPJDl0bltV7TI+P3ORw86cbT+6z0z7L2cIW2b73CvJwZvpc7Hz3K6qZqePu0+Sy5J8bhn9AAAAAAAALNmPjaxZiu7+96r65SQvT/L8DOHN08fdH0jypO4+d4U1HZvkjVX18SQfTfLUDFO6vT5Jqur4JF/t7qPG9i9PckZVPS3JqUkekeTOSR4/1tpV9bIkz66qczKEO89PckGSk+dOWlX7J9knyf5Jdq2qO4y7vtjd380w0uhzSf6uqp6RYZ2cFyR5VXdfscLXCgAAAAAAsFkrCnOSpLs/m+RXq+oGSX4uwyif/+zur29NQd19UlXdOMnRGQKTs5Lcr7svHpvsn+SamfYfrqpHZQhWXpTknCQP7u7PzHT7lxkCoeOS7J3kQ2Ofl8+0OTrJY2eef3L8eK8kH+juq6vqsCSvzjBK53tJ3pjkL7bm9QIAAAAAAGxOdfda17DTGKd3uzTJhnENHQAAAAAAYCe11NxgRSNzqup3l9Kuu49fSf8AAAAAAAAMVjQyp6qu2czu/+6wu3ddSVHrlZE5AAAAAADAnO06MifJgQts2zXJAUmemGFdm8cu0AYAAAAAAIBl2C5r5lTVqUnO7e4nbfPOd2BG5gAAAAAAAHOWmhvssp3Of0qSh2+nvgEAAAAAAHYa2yvM+dkku2+nvgEAAAAAAHYaK1ozp6rusciuvZPcI8mRSU5eWUkAAAAAAADMWVGYk+QDSRZabKeSXJ3kH5L8zxX2DQAAAAAAwGilYc69FtjWSb6d5CubW6QHAAAAAACApVtRmNPdZ2zrQgAAAAAAAPhxu6x1AQAAAAAAACxuSSNzqurLWXiNnM3p7v7Z5ZcEAAAAAADAnKVOs3ZGlh/mAAAAAAAAsJWWFOZ09+HbuQ4AAAAAAAAWYM0cAAAAAACACVvqNGsLqqrrJLllkg1ZIBjq7g9uTf8AAAAAAAA7uxWFOVW1S5IXJ3likp/cTNNdV9I/AAAAAAAAg5VOs/ZnSZ6e5O+T/G6SSvLMJEck+XSSTyW577YoEAAAAAAAYGe20jDn8CRv6e4/SvLucdsnuvs1SQ5O0knuvfXlAQAAAAAA7NxWGubsl+R94+dXjB+vlyTdfWWGETu/s3WlAQAAAAAAsNIw55tJrp8k3f3dJJclufm8NjfYiroAAAAAAABIstsKj/tkkrvMPH9/kqdW1SczBERHZlg3BwAAAAAAgK2w0pE5r0mye1XtPj5/VpK9k3wwyRlJ9krytK2uDgAAAAAAYCdX3b20hlUvSfJ33b3giJuq2pDknkmuTvLh7v7WtipyvaiqvZJcmmRDd1+21vUAAAAAAABrZ6m5wXLCnGuSdJIvJPn7JG/q7q9sg1p3GsIcAAAAAABgzlJzg+VMs/bzSY4ej3lhkv+sqg9V1RFVdcOtqhYAAAAAAIAFLXlkzrUOqrpTkkcn+e0kN0vywySnJTkhyTu7+wfbssj1wsgcAAAAAABgzjafZm2Rk1SGdXIeleQhSW6Q5LtJTk5yQneftuLO1yFhDgAAAAAAMGdVwpx5J7xOkl9P8kdJ7pvkmu7ebZt0vk4IcwAAAAAAgDlLzQ22SdhSVddNcliGETr3HDdfvC36BgAAAAAA2JmtOMwZp1g7NEOA85tJNiT5TpKTkvx9kvdtiwIBAAAAAAB2ZssOc6rqrhkCnN9Osm+Sq5KcliHAeWd3X75NKwQAAAAAANiJLTnMqaqjkzwyyc2TVJIPJ3l+kpO6+1vbpzwAAAAAAICdW3X30hpWXZPkC0lOSHJCd5+7Hetal5a6kBEAAAAAALD+LTU3WM40awd19ye3ujIAAAAAAACWbJelNhTkAAAAAAAArL4lhzkAAAAAAACsPmEOAAAAAADAhAlzAAAAAAAAJmxJYU5VHVtVd5x5vn9V/cT2KwsAAAAAAIBk6SNznprkVjPPv5zkN7d5NQAAAAAAAFzLUsOci5PcfOZ5bYdaAAAAAAAAmGepYc6pSf6iqj5YVe8ctz2tqt65mcc7VlpUVT2pqs6tqsuralNV3XUL7R9WVV8Y259dVfeft7+q6uiqurCqflBVp1fVLea12aeqTqiqy6rqkqp6bVVdf16b+1bVR6rqO1X19ap6W1UdsNLXCQAAAAAAsCVLDXOekuQlSa6T5DZJOslPJ7ndFh7LVlUPT3JskucluVOSTyU5rapuskj7uyV5c5LXJrljkpOTnFxVt51p9owkRyY5IsnBSb439nm9mTYnjK/tPkkOS3KPJMfNnOfAJO9I8r4kd0hy3yQ3SvKPK3mdAAAAAAAAS1HdvfyDqq5J8pjuftM2L6hqU5KPdfeTx+e7JDkvySu7+5gF2p+UZI/uPmxm20eSnNXdR1RVJbkgyUu7+yXj/g0Zpo47vLtPrKpbJflckrt098fHNvdL8q4k+3X3BVX10Ayh0e7dfc3Y5oEZAp7du/uHC9S2e5LdZzbtmeT8JBu6+7Kt+DIBAAAAAAA7uKraK8ml2UJusNSROfPdK8l7VnjsoqrqukkOSnL63LYxODk9ySGLHHbIbPvRaTPtD0yycV6flybZNNPmkCSXzAU5o9OTXJNhJE+SfGJ8/ntVtesYCP1OktMXCnJGR2X4Jsw9zl+kHQAAAAAAwIJWFOZ09xnd/fVtXUyGact2zTBqZtbFGQKZhWzcQvuNM9s21+Zrszu7+6ok35pr091fTvJrSV6U5IoklyTZL8lvb+b1vDjJhpnHfptpCwAAAAAA8GN2W+mBVfWLSf5nhnVtNuTHg6Hu7p/ditompao2JnlNkjdmmG5tzyRHJ3lrVd2nF5ivrruvyBD8zPWxStUCAAAAAADrxYpG5lTVPZN8NMlhGdajuXmS/xw//5kk303ywRV0/Y0kVyfZd972fZNctMgxF22h/UUz2zbX5iazO6tqtyT7zLR5UpJLu/sZ3f3J7v5gksckOTQ/mooNAAAAAABgm1rpmjlHZwhvfiHJ743bXtTdv5zkbhmmE3vLcjvt7iszrE1z6Ny2qtplfH7mIoedOdt+dJ+Z9l/OEMjM9rlXhgBmrs2ZSfauqoNm+rh3hq/PpvH5T2ZYM2fW1ePHlX4dAQAAAAAANmulIcSdkry2uy/LjwKNXZOkuzcl+dskz19h38cm+cOqemxV3SrJq5PskeT1SVJVx1fVi2favzzJ/arqaVV1y6p6bpI7J/nrsZ5O8rIkz66qB1XV7ZIcn2EU0cljm88neXeS11TVXavql8bjT+zuC8bznJrkLlX1F1V1i6q601jTV5J8coWvFQAAAAAAYLNWumbOVUm+M35+SZIf5trTlP1nkluvpOPuPqmqbpxh9M/GJGcluV93Xzw22T8zI2S6+8NV9agkL0jyoiTnJHlwd39mptu/zBAIHZdk7yQfGvu8fKbNozMEOO8d+39bkiNnzvO+8TzPGB/fzzCi537d/YOVvFYAAAAAAIAtqWHgyjIPqvp4kvd399PH559Kck53P3R8fnKSX+zum2/DWnd44/RulybZMI5qAgAAAAAAdlJLzQ1WOs3au5I8sqrmRvYcm+QhVXVOVZ2T5EEZploDAAAAAABgK6x0ZM51kuyV5FvjmjSpqsck+a0Ma+ic0t1v2IZ1rgtG5gAAAAAAAHOWmhusKMxhZYQ5AAAAAADAnO09zRoAAAAAAACrYLctN1lYVd03ye8nuXmSGySpeU26u392K2oDAAAAAADY6a0ozKmqpyc5JsnFST6a5OxtWRQAAAAAAACDlY7MeUqS9yW5f3f/cBvWAwAAAAAAwIyVrplzgyRvFeQAAAAAAABsXysNcz6a5Be2ZSEAAAAAAAD8uJWGOU9M8pCqetS2LAYAAAAAAIBrq+7ecqOqTy+weZ8kP5Xku0nOT3L1vP3d3bff6grXkaraK8mlSTZ092VrXQ8AAAAAALB2lpob7LbE/r6VZH7q880k56ysPAAAAAAAAJZiSWFOd99zO9cBAAAAAADAAla6Zg4AAAAAAACrYEVhTlVdU1UXVtU9Ftn/6Kqav4YOAAAAAAAAy7Q1I3Oul+T0qnrKtioGAAAAAACAa9uaMOepSV6T5K+q6u+q6nrbpiQAAAAAAADmbE2Y88PuflKSw5M8JMm/VtX+26QqAAAAAAAAkmxdmJMk6e7jk/xSkr2TfKKqDt3aPgEAAAAAABhsdZiTJN19VpKDknwsybuT/P626BcAAAAAAGBnt03CnCTp7kuSPCDJi5L8yrbqFwAAAAAAYGe22wqPOzDJ1+dv7O5O8pyq+ockN9yawgAAAAAAAFhhmNPdX9nC/s+srBwAAAAAAABmrXRkTqrqBkkemeTmSW6QpOY16e62dg4AAAAAAMBWWFGYU1X3TfLWJHskuSzJtxdo1ltRFwAAAAAAAFn5yJyXJrkoyUO6++xtWA8AAAAAAAAzdlnhcT+X5BWCHAAAAAAAgO1rpWHOOUn23JaFAAAAAAAA8ONWGuY8O8kTq+qAbVgLAAAAAAAA86x0zZxDk3w9yeer6j1Jzkty9bw23d1P2ZriAAAAAAAAdnbV3cs/qOqaJTTr7t51+SWtX1W1V5JLk2zo7svWuh4AAAAAAGDtLDU3WNHInO5e6fRsAAAAAAAALINQBgAAAAAAYMKEOQAAAAAAABO24jCnqn69qt5TVd+sqquq6ur5j21ZKAAAAAAAwM5oRWFOVf1WklOS7JvkxLGfN4+f/yDJp5McvY1qBAAAAAAA2GmtdGTOUUk+muSOSZ4zbntddz86yW2T/FSSL299eQAAAAAAADu3lYY5t05yYndfneSqcdt1kqS7z03y/yX5062uDgAAAAAAYCe30jDn+0muTJLuviTJFRlG48y5OMmBW1UZAAAAAAAAKw5z/j3D6Jw5ZyX5nararaqul+RRSf5rK2sDAAAAAADY6a00zHl7kt+oqt3H5y9Mcs8klyT5epK7Jzlma4sDAAAAAADY2a0ozOnul3T3/t19xfj8lAxhzmuS/G2SQ7v7DSstqqqeVFXnVtXlVbWpqu66hfYPq6ovjO3Prqr7z9tfVXV0VV1YVT+oqtOr6hbz2uxTVSdU1WVVdUlVvbaqrr9AP39SVf9RVVdU1Ver6lkrfZ0AAAAAAABbstKROT+mu/+lu/9Xd/9Jd79/pf1U1cOTHJvkeUnulORTSU6rqpss0v5uSd6c5LVJ7pjk5CQnV9VtZ5o9I8mRSY5IcnCS7419Xm+mzQlJbpPkPkkOS3KPJMfNO93Lk/xBkj9JcsskD0ry0RW+VAAAAAAAgC2q7t76Tqp2S3KLJNdP8vnu/u5W9LUpyce6+8nj812SnJfkld39Y1O3VdVJSfbo7sNmtn0kyVndfURVVZILkry0u18y7t+Q5OIkh3f3iVV1qySfS3KX7v742OZ+Sd6VZL/uvmBs8+kkt+3uf1/ha9sryaVJNnT3ZSvpAwAAAAAAWB+Wmhssa2ROVd2/qv6uql5fVfcetz04yblJPpPkI0m+XlUvWGHR101yUJLT57Z19zXj80MWOeyQ2faj02baH5hk47w+L02yaabNIUkumQtyRqcnuSbDSJ4keWCS/0xyWFV9eZwG7v9W1T6beT27V9Vec48key7WFgAAAAAAYCG7LbXhOFLllCQ/TPKDJI+pqsdlmN7sc0n+YezvvkmOqqqvdPdrllnPjZLsmmHUzKyLM0xrtpCNi7TfOLM/S2jztdmd3X1VVX1rps3Nk/xMkocl+d2xzr9K8tYk916ktqOSPGeRfQAAAAAAAFu05DAnw7ozn0lyj+6+pKr+JsnfJnlPksN6nK9tnHLtIxnWp1lumDNluyTZPcnvdvd/JElV/X6ST1TVLywy9dqLM6z/M2fPJOdv90oBAAAAAIB1YznTrN0myRu6+5Lx+SuSXC/J3/fMwjvdfVWSE7L4SJrN+UaSq5PsO2/7vkkuWuSYi7bQ/qKZbZtrc5PZnWMotc9MmwuTXDUX5Iw+P37cf6HCuvuK7r5s7pHkO4u8BgAAAAAAgAUtJ8y5ca49VdnctGTzpy+b23e95RbT3Vcm+USSQ+e2VdUu4/MzFznszNn2o/vMtP9yhkBmts+9MqyFM9fmzCR7V9VBM33cO8PXZ9P4/F+T7FZVPzvT5ufHj1/Z0msDAAAAAABYieVMs5Ykvcjn29KxSd5YVR9P8tEkT02yR5LXJ0lVHZ/kq9191Nj+5UnOqKqnJTk1ySOS3DnJ45Oku7uqXpbk2VV1ToZw5/lJLkhy8tjm81X17iSvqaojklwnyV8nObG7LxjPc3qSf0vyuqp6aoag51VJ3jNvtA4AAAAAAMA2s9ww54CqutP4+Ybx4y2q6pJ57Q5caUHdfVJV3TjJ0Uk2Jjkryf26e24E0P5Jrplp/+GqelSSFyR5UZJzkjy4uz8z0+1fZgiEjkuyd5IPjX1ePtPm0RkCnPeO/b8tyZEz57mmqh6Y5JVJPpjke0n+KcnTVvpaAQAAAAAAtqRmlrvZfMOqa/Ljo3FqgW3/vb27d9268taXcXq3S5NsGNfQAQAAAAAAdlJLzQ2WMzLn97a6KgAAAAAAAJZlyWFOd79xexYCAAAAAADAj9tlrQsAAAAAAABgccIcAAAAAACACRPmAAAAAAAATJgwBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmTJgDAAAAAAAwYcIcAAAAAACACRPmAAAAAAAATJgwBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmTJgDAAAAAAAwYcIcAAAAAACACRPmAAAAAAAATJgwBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmTJgDAAAAAAAwYcIcAAAAAACACRPmAAAAAAAATJgwBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmTJgDAAAAAAAwYcIcAAAAAACACRPmAAAAAAAATJgwBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmbJJhTlU9qarOrarLq2pTVd11C+0fVlVfGNufXVX3n7e/quroqrqwqn5QVadX1S3mtdmnqk6oqsuq6pKqem1VXX+R8/1cVX2nqi7Z6hcLAAAAAACwGZMLc6rq4UmOTfK8JHdK8qkkp1XVTRZpf7ckb07y2iR3THJykpOr6rYzzZ6R5MgkRyQ5OMn3xj6vN9PmhCS3SXKfJIcluUeS4xY433XG8/3Lil8kAAAAAADAElV3r3UN11JVm5J8rLufPD7fJcl5SV7Z3ccs0P6kJHt092Ez2z6S5KzuPqKqKskFSV7a3S8Z929IcnGSw7v7xKq6VZLPJblLd398bHO/JO9Ksl93XzDT9/9OctMk703ysu7eexmvba8klybZ0N2XLfmLAgAAAAAArDtLzQ0mNTKnqq6b5KAkp89t6+5rxueHLHLYIbPtR6fNtD8wycZ5fV6aZNNMm0OSXDIX5IxOT3JNhpE8c/XdO8nDkjxpia9n96raa+6RZM+lHAcAAAAAADBnUmFOkhsl2TXDqJlZF2cIZBaycQvtN85s21ybr83u7O6rknxrrk1V3TDJGzKM5lnqqJqjMiRqc4/zl3gcAAAAAABAkumFOVP2miRv6u4PLuOYFyfZMPPYb3sUBgAAAAAArF9TC3O+keTqJPvO275vkosWOeaiLbS/aGbb5trcZHZnVe2WZJ+ZNvdO8idVdVVVXZXktUk2jM8ft1Bh3X1Fd18290jynUVeAwAAAAAAwIImFeZ095VJPpHk0LltVbXL+PzMRQ47c7b96D4z7b+cIZCZ7XOvDGvhzLU5M8neVXXQTB/3zvD12TQ+PyTJHWYef5EhnLlDkrcv5fUBAAAAAAAs125rXcACjk3yxqr6eJKPJnlqkj2SvD5Jqur4JF/t7qPG9i9PckZVPS3JqUkekeTOSR6fJN3dVfWyJM+uqnMyhDvPT3JBkpPHNp+vqncneU1VHZHkOkn+OsmJ3X3BXJvZIqvqzkmu6e7PbIevAQAAAAAAQJIJhjndfVJV3TjJ0Uk2Jjkryf26++Kxyf5Jrplp/+GqelSSFyR5UZJzkjx4XsjylxkCoeOS7J3kQ2Ofl8+0eXSGAOe9Y/9vS3Lktn59AAAAAAAAy1HdvdY17DTG6d0uTbJhXEMHAAAAAADYSS01N5jUmjkAAAAAAABcmzAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwiYZ5lTVk6rq3Kq6vKo2VdVdt9D+YVX1hbH92VV1/3n7q6qOrqoLq+oHVXV6Vd1iXpt9quqEqrqsqi6pqtdW1fVn9t+zqt4x9vG9qjqrqh69bV85AAAAAADAtU0uzKmqhyc5NsnzktwpyaeSnFZVN1mk/d2SvDnJa5PcMcnJSU6uqtvONHtGkiOTHJHk4CTfG/u83kybE5LcJsl9khyW5B5JjpvZf7ckn07yW0l+McnrkxxfVYdtxcsFAAAAAADYrOruta7hWqpqU5KPdfeTx+e7JDkvySu7+5gF2p+UZI/uPmxm20eSnNXdR1RVJbkgyUu7+yXj/g1JLk5yeHefWFW3SvK5JHfp7o+Pbe6X5F1J9uvuCxap9dQkF3f345b42vZKcmmSDd192VKOAQAAAAAA1qel5gaTGplTVddNclCS0+e2dfc14/NDFjnskNn2o9Nm2h+YZOO8Pi9NsmmmzSFJLpkLckanJ7kmw0iexWxI8q3NvJ7dq2qvuUeSPTfTFwAAAAAAwI+ZVJiT5EZJds0wambWxRkCmYVs3EL7jTPbNtfma7M7u/uqDEHNguetqt9OcpcM060t5qgMidrc4/zNtAUAAAAAAPgxUwtzdghVda8MIc4fdvdnN9P0xRlG78w99luF8gAAAAAAgHVkt7UuYJ5vJLk6yb7ztu+b5KJFjrloC+0vmtl24bw2Z820uclsB1W1W5J95p+3qn4lyf9L8r+6+/jFX0rS3VckuWLm2M01BwAAAAAA+DGTGpnT3Vcm+USSQ+e2VdUu4/MzFznszNn2o/vMtP9yhkBmts+9MqyFM9fmzCR7V9VBM33cO8PXZ9PMcfdMcmqSP+3u45b+ygAAAAAAAFZmaiNzkuTYJG+sqo8n+WiSpybZI+PaNFV1fJKvdvdRY/uXJzmjqp6WIWh5RJI7J3l8knR3V9XLkjy7qs7JEO48P8kFSU4e23y+qt6d5DVVdUSS6yT56yQndvcF43nvleSU8Xxvq6q5tXSu7O5vbZ8vBQAAAAAAsLObXJjT3SdV1Y2THJ1kY4ap0O7X3RePTfZPcs1M+w9X1aOSvCDJi5Kck+TB3f2ZmW7/MkMgdFySvZN8aOzz8pk2j84Q4Lx37P9tSY6c2f/YJD+Z5KjxMeeMJPdc8QsGAAAAAADYjOruta5hpzFO73Zpkg3dfdla1wMAAAAAAKydpeYGk1ozBwAAAAAAgGsT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAnbba0LYOd2wDNP3TXJ3ZP8VJILk/zLucc84Oq1rYr1zDXHanK9sdpcc6wm1xurzTXHanPNsZpcb6w21xzseCY5MqeqnlRV51bV5VW1qaruuoX2D6uqL4ztz66q+8/bX1V1dFVdWFU/qKrTq+oW89rsU1UnVNVlVXVJVb22qq4/r80vVtW/jOc5r6qese1e9c7ngGee+pAk5yZ5f5I3jR/PHbfDNueaYzW53lhtrjlWk+uN1eaaY7W55lhNrjdWm2sOdkyTC3Oq6uFJjk3yvCR3SvKpJKdV1U0WaX+3JG9O8tokd0xycpKTq+q2M82ekeTIJEckOTjJ98Y+rzfT5oQkt0lynySHJblHkuNmzrNXkn9O8pUkByV5epLnVtXjt+4V75zG/xzemuRm83bdLMlb/efBtuaaYzW53lhtrjlWk+uN1eaaY7W55lhNrjdWm2sOdlzV3Wtdw7VU1aYkH+vuJ4/Pd0lyXpJXdvcxC7Q/Kcke3X3YzLaPJDmru4+oqkpyQZKXdvdLxv0bklyc5PDuPrGqbpXkc0nu0t0fH9vcL8m7kuzX3RdU1R8leWGSjd195djmmCQP7u5bLvG17ZXk0iQbuvuy5X911odxGOe5Gf6TqAWadJLzkxxoeCfbgmuO1eR6Y7W55lhNrjdWm2uO1eaaYzW53lhtrjmYpqXmBpMKc6rqukm+n+Sh3X3yzPY3Jtm7u39jgWP+K8mx3f2ymW3PyxCy3L6qbp7kS0nu2N1nzbQ5I0Pg85SqelyGsOcGM/t3S3J5kod199ur6vgke3X3g2fa3CvJ+5Ls093fXqC23ZPsPrNpzww/EHe6MOeAZ556+wwjn5LkVkmevYTDXpDk8+Pnnz33mAd8anvUxvrkmmM1ud5Yba45VpPrjdXmmmO1ueZYTa43VptrDqZvqWHObqtX0pLcKMmuGUbNzLo4yWKjXzYu0n7jzP4soc3XZnd291VV9a15bb68QB9z+34szElyVJLnLFL3zublSX5lmcfM/udyRpJ7brNq2Bm45lhNrjdWm2uO1eR6Y7W55lhtrjlWk+uN1eaag3ViamHOevPiDOv/zJkbmbMzekq28l0A26Mo1jXXHKvJ9cZqc82xmlxvrDbXHKvNNcdqcr2x2lxzsE6YZm07TrO2QK3WzIn5OVl9rjlWk+uN1eaaYzW53lhtrjlWm2uO1eR6Y7W55mCalpob7LJ6JW1Zd1+Z5BNJDp3bVlW7jM/PXOSwM2fbj+4z0/7LSS6a1+deSQ6eaXNmkr2r6qCZPu6d4euzaabNParqOvPO8+9LCXL4kfE/g6eMT+eniXPPn+o/DbYV1xyryfXGanPNsZpcb6w21xyrzTXHanK9sdpcc7Bjm1SYMzo2yR9W1WOr6lZJXp1kjySvT5KqOr6qXjzT/uVJ7ldVT6uqW1bVc5PcOclfJ0kPQ49eluTZVfWgqrpdkuOTXJDk5LHN55O8O8lrququVfVL4/EndvcF43nelOTKJK+tqttU1cMz/PCbnUaNJTr3mAf8Y5KHJvnqvF3nJ3nouB+2Gdccq8n1xmpzzbGaXG+sNtccq801x2pyvbHaXHOw45rUNGtzqurJSZ6eZGOSs5Ic2d2bxn0fSHJudx8+0/5hGeZyPCDJOUme0d3vmtlfSZ6X5PFJ9k7yoSRP7O7/mGmzT4YA54FJrknytvG8351p84tJXpXkLkm+keSV3f2/l/G6TLM2zzi88+5JfirJhUn+RfrP9uSaYzW53lhtrjlWk+uN1eaaY7W55lhNrjdWm2sOpmOpucEkw5z1SpgDAAAAAADM2SHXzAEAAAAAAODahDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJmy3tS5gJ7VnVa11DQAAAAAAwNracymNhDmra+6bcv6aVgEAAAAAAEzJnkkuW2xndfcq1rJzq2E4zk2TfGeta5mYPTMEXPvF14bV4ZpjNbneWG2uOVaT643V5ppjtbnmWE2uN1aba47V5HrbvD2TXNCbCWyMzFlF4zfiq2tdx9TMTDn3ne5eNHmEbcU1x2pyvbHaXHOsJtcbq801x2pzzbGaXG+sNtccq8n1tkVb/JrsshpVAAAAAAAAsDLCHAAAAAAAgAkT5jAFVyR53vgRVoNrjtXkemO1ueZYTa43VptrjtXmmmM1ud5Yba45VpPrbSvVZtbTAQAAAAAAYI0ZmQMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAA7sKqqta4BAAAA2L6EOawZN58AYOt1d1eV3+kAAHYwc/dF3B9hNbneYMflD3/WTHf3WtfAzsEvKqw21xyroaoeUlV/VlXX7e5rxm1+t2O7qaqbVtVPrHUd7Dyq6uer6t5Vteta18LOoap+v6pOcM2xin6yqnafuz/i7whWg/txbG9+lm0/5d8vq6mqbpvk0CQ3TnJBkncl+XZ3X7qmhQFsA1V1UJJHJLlpktO7+/VrXBLr1BjafDPJhiQfTvKK7n7LzP7yRxrbUlXtluT8JH+U5GTXF9vbeDP99CSXJXl2d5+9xiWxzo3X3NeS3CDJsUn+vLt/4P9UtofxRufhSX4/yX5J3tjdz1nToljXquqnktwrw98P305yapIru/uKNS2Mdauq9k7ywCTXT/Ll7n732la0Puy21gWw86iqozLcANgvww2ovZK8MMnbq+otSc4U6rAtVdVhSa5M8uHu/u5a18P6VlV/nORJGYKcbyf57aq6dZJnZnjz0zVrWR/rzk0z3HBKkt2T/E1VPSzJMd39iZl3d+7i2mMbOTbDqP7z3dRklbw0yc2T/PFskFNV+3T3t9xgZzv464x/OyT5n0nOznCD3XXG9vCcJH+Q5DtJvpzkz6vq6u4+em3LYj2qqiOTHJnh/9VOUkn+K8kbq+q0JJ/q7u+tYYmsM1X1uCT/K8ltxk3fGu/9Pqe7v752le34jMxhVVTVgUm+kORvkhyT5DpJfibJ/ZM8YWz2N0le091f9scZW6uqDkjyn+PjDUn+Mcl/dPdV437XGNtMVd08ySeSnJjk6AxvljgxyU8k+ZUMNwb28ksL21JVPTLJszLcZP/lDO96ujLJm5O8pLsvqqpjkhzf3Z9bu0rZ0VXVzyX5jyRPS3Jcd3+vqjYk+R9JDkyyd5ITu/vcNSuSdWV89/CnMgQ6r+7uy6rqAUkekuH/1a8n+X8ZRu58srt/uGbFsi5U1c8mOSfDmw9PSfKaDDNKHJHk+HhjDtvQeH/ks0n+KslfJvlhkhOSXJ0h4LlThp9z/5XkMn+3sjXGv1U/k+SdGd5Qfb0kD07yxAyjdD6d5HUZfse73L0Sttb4M+7MDG+OeGmGNx8+Ncl9kzy5u1+zdtXt+IQ5rIqq+vMkj0lyWHefM2/f/kn+PMnvJXlvkt/t7otXv0rWk6r6P0menOSTSQ7OcEPgr5O8p7vPm2nnFxW2WlW9NclPJ3lsd39h3PakJH+a5ENJbpjklzLcdDq6u/9trWpl/RiHrZ+W5CPd/ZRxZM4Tktw5w3RY52R408SduvuzRumwUlX17gzTDj28u88db7SfkOSe85q+KslTXGdsrar6H0lOSvI/u/udY6D4ySTfyvAGsT0y/H73xSR/1t1vX7NiWReq6j1J9kzy6O7+UlXdM8ObI76T5IHd/e9rWB7rTFW9JMP/oY+Z+dvhNzO8SefGSfbJ8HPujCQv7O7T16hU1oGqOi7JXTP8HvfvM9sfneTvMoSG+2d4c/UTFu4Flq6qTsrwBv7D537GjdtPzvD72x27+6I1Km+HZ5FcVsu3MkwJs1uSVNV153Z093919x8meXSS2yc5rap+ek2qZF2oqo0Zbpyfk+SwDOn/FRneYff/VdUDqmqf5EcL/1XVvlW1xxqVzA5sXAvsoAw3nWbD6jsn2ZjkG0neluT/JLlDkvdX1d1WuUzWoe6+JMkfJ/mNqrprd/9Dkt9K8tyxyQMyXH+3Gtu7wc6yVdWvJvm1DOsczk2H+4YkP5/kqAx//D8iyRszTDV5WlXdcPUrZZ35doY3Scx5VZLPJbl/d983w+92h47tTqyqX0sstsvKjKO+Ds3w7uFzk6S7P5DkQUl+Mskp47qIrjG2letmuDdy7sy2Bya5dYab6w/P8H/qDZO8s6oemLj+WL5xLbDrJbl8Lsipqt3H3e9I8m9JXpvhXskfVtWL1qRQ1o1xVM6tkvxzki+N2+buAb8uyb4ZZpWYWwc2VfUTq1/pjkuYw2r5jwy/rPxGknT3lVW167xfRt6R5NkZ5lP89dUvkXWkk+ya5Izu/laS92V4d/qRGQLDE5McXVWHVNUuVXWdDOuafGScNgaW4ycyvDP4S919dfLfAc9jkzw9yTO6+7gMU2E9I8O7Ph+xRrWyjox/nH08ww3Ov6mqjd19aXe/LMNoxCsz/Dx8TVW9ZeYPN1iOm2S4YX5kkiOq6g+S3CPDehIv7e7zu/stGX6+vTLDDdFfWqtiWTe+kuQjSR41/p6WJCd392fHz7/f3R/MMCXW1zOM8P/vN+nAMj02ww30M7r76vHvg10yjAZ7QZKfTfLsqrp+d7cb6mwD30nyi0nuXFU3qKrfyzCTydMyrCfxriSvzxDofG/86Gccyzb+fXpJkjuMN9nT3VdU1W4Z/lb4qQz/5z4xwxt3HjdOWQ8rtVeSGyU5r7t/OM6Gc2WSdPc7M9wfnrs3fM34e94TqmpTVf3kmlW9AzHNGqumqv4qyVMyzAt7dHdfOm7fNck1MyMkPp7hHSq/7V3ErFRV7Zkk3f2dedsPyHAD6ogMf/y/Msk3M6zl9K/d/VurWyk7uvFn2O26+6yZbY/LMHz4qPmLNFfVJ5Ocl2He/6v9UcbWGqcfOjXJc7v7zVV1pySbMoSJn8lwk/3T3f0na1gmO6jxZ9zPZZjn+vAMc16fmmHahG/O/h43/jF2aYY1Tp62RiWzToz/l/7fJH+fYcHmr3T3o+dPkTsupntghhFkl/h/leWqqhsk2bO7/2uR/f8rwwjrNyc5wiLhbK2qukmG9UvumuT7SS7P8GbE+3T3x+f97fD2DD/j7ms6elZifKPhBzOs0/SyDOsJ3zDD3whHZJjy6ktVdcskZyV5XHe/aW2qZUc3jrJ5dpK/6+4vzP08m5vyu6pemCE8/NnxXsmtM8xk8sXufuBa1r6j2G2tC2Cn8twMC+T+XpJbV9Wru/udc+9+StLjqIjzM/zHsksSYQ4rMj/Emdl+blU9PclbMtzofHGGX553S/K41auQ9WJ8t9NZ87a9rqre3t3fHjdVhp9xGzP8wXbN2M4NJ7bK+MvxF6vqlCTHVtXHMoTTZ2d4F/u5VfXeDDcIYNnGn3H/XlVHZhjZ+oQk3+7ub87tn3mX+s2SXJDkJ6xJxzbwhgwjIp6S4f/Rfarq3t39vpkbAnsn+UGGKYu+75pjJcbf1749f/vMWnPHZbgWn5jki1X1grnR2LAS3f21qvrtJL+dYbrSLya5XYZROMlwL+Tq8WfcNRlGWl+6QFewRd39mao6LMNam3+X5CVJrpNhKYT/mWFkTjJcZ9/IsGYTrEh3/yDJs+ZGVs/9bjbzZv3TMkzVfEhVvS/J72R4087/WINyd0imWWPVjCNxfj/DNB13TvLqqnpzVf3a+MfYPhmmwrp7knd191VrWC7rWHdf092bMqzT9NdJrp9hBIVfkNlqczc1Z4Kc2V9cbpPklklO9zOObWHmxuVLk3wtw83Pe2YIdM6baeOmE1ulu3/Y3WckeXKGaYf+e57rmevw5zPcAPg3N9XZWuP/nX+e5A8yvPHmlkn+vqr+OMntquoWSf4wyW8meVN3X7FmxbIuzf3+No7EeU6GKYj+NMMoReuXsFXGtYNf0t1HdvcrMswa8a6qOngmLLx3hqlN39zdl69ZsezwuvvDSW6Q4Q0Sn8rw8+x3uvtVM3+X/kyGN0d8Y22qZD3p7h8usmtThjd/3TfDmsJHJHm++3FLZ5o11kRV7ZXkLzK8E+VmSS7O8K66fZJ8tIeFTWG7mBnmeYskf5vkgO6++VrXxfo08+7hOyR5XpLbdPfPrXFZrENV9TsZFgn/pyRHmoqD1TDzM+52SZ6fYdrJn13rulhfxulz/yzJ4zPcjLoyw7vVr8rwBomHrGF5rHMzfzvcMMkHklynu2+5xmWxzlTVbZK8PcObrj+WYUTioUk+192/spa1sb5U1a7zRxeOf6s+M8lB3X2LNSmMdW/m/9P/m+QBGaYEv2V3//Qal7ZDEeawpsYph349w5DifZK8I8lHuvvCNS2MdW98J91jkrwxyYPHhdhgu6iq/ZK8LsO7ih/X3aevcUmsU+Ocwz/s7nPWuhZ2HlV1syR/k2Hu/9/t7tPWuCTWqaraN8PaOLdMsiHJKUk+0d1fX9PC2GlU1a8n+dY4yh+2qaq6eYY35hycYY26v0nyf7v782taGOtaVe2eYRr6Q5I8prv/eY1LYp2aCXPunyG8vk6SB3X3KWtc2g5FmAPstKrqukke1t0nrHUtrG9V9fMZpor55+7+u7WuB2BbGkPEv0pySne/cq3rAYAd2Rhc79bdX13rWlj/xjDnbkn2cFOd1TCul356knO7+2FrXc+ORpgDAKtgHA1WM+vnAKwb4/o5u1gPDAAA2Jyq2i3JT3T3d9a6lh2NMAcAAAAAAGDCdlnrAgAAAAAAAFicMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAgHmq6vCq6qq681rXAgAAIMwBAAAAAACYMGEOAAAAAADAhAlzAAAAtqCq3lBV362q/avqlPHzr1bVk8b9t6uq91XV96rqK1X1qHnH71NVL6mqs8djL6uqf6qq2y9wrp+pqneOfX2tqv6qqu47Tvt2z3ltD66qd1fVpVX1/ao6o6p+aXt+LQAAgNUnzAEAAFiaXZP8U5LzkjwjyblJ/rqqDk/y7iQfT/KnSb6T5PiqOnDm2JsneXCSU5L8cZL/k+R2Sc6oqpvONaqqPZK8L8mvJnlFkhcmuVuS/z2/mKq6d5IPJtkryfOS/FmSvZO8r6ruuk1eMQAAMAm7rXUBAAAAO4jrJfn77n5xklTVm5JckOR1SR7Z3SeN29+T5AtJHpvkueOxZyf5+e6+Zq6zqvq7sd3vJ3n+uPkJGYOf7n7H2O5vk3xytpCqqiR/k+T9SX69u3um7WeTvCDJr23D1w4AAKwhI3MAAACW7v/OfdLdlyT59yTfS/KWme3/nuSSDKHM3LYr5oKcqtq1qm6Y5Lvj8Xea6f9+Sb6a5J0zx16e5DXz6rhDklskeVOSG1bVjarqRkn2SPLeJPeoKn/vAQDAOmFkDgAAwNJc3t1fn7ft0iTnz42Mmbf9BnNPxmDlKUmemOTADFO2zfnmzOc/k+RLC/T3xXnPbzF+fONm6t2Q5Nub2Q8AAOwghDkAAABLc/Uyt9fM53+WYSq11yX58yTfSnJNkpdlZTMmzB3z9CRnLdLmuyvoFwAAmCBhDgAAwPb30CTv7+7fn91YVXsn+cbMpq8kuXVV1bzROT83r78vjR8v6+7Tt3WxAADAtJhDGQAAYPu7OtceqZOqeliSm81rd9q47UEz7a6X5A/ntftEhkDnT6rq+vNPVlU33gY1AwAAE2FkDgAAwPZ3SpK/qKrXJ/lwktsleXSS/5zX7m+TPDnJm6vq5UkuHNtdPu7vJOnua6rqD5L8U5LPjv1+NUMQdK8klyV54HZ9RQAAwKoR5gAAAGx/L0qyR5JHJXl4kn9L8oAkx8w26u7vVtW9k7wyyVMyrHtzfIYA6G35UaiT7v5AVR2SYQ2eJye5fpKLkmzKEAoBAADrRF17GmYAAACmpqqemuSvkuzX3V9d43IAAIBVJswBAACYkKr6ie7+wczz6yX5ZJJdu/vn164yAABgrZhmDQAAYFr+sar+K8lZSTYkeUySW2ZYOwcAANgJCXMAAACm5bQkf5AhvNk1yeeSPKK7T1rTqgAAgDVjmjUAAAAAAIAJ22WtCwAAAAAAAGBxwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACbs/we3NNytU0CyywAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "high_dvl = df.iloc[-30:]\n", "high_dvl.index = high_dvl.index.map(str)\n", @@ -591,9 +1078,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "low_dvl = df.iloc[:30]\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -617,7 +1117,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -631,17 +1131,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ - "utility = Utility(\n", - " model=TorchCNNModel(),\n", - " data=dataset,\n", - " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", - ")\n", - "\n", + "from sklearn.linear_model import SGDClassifier\n", "\n", + "if not is_CI:\n", + " utility = Utility(\n", + " model=TorchCNNModel(),\n", + " data=dataset,\n", + " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", + " )\n", + "else:\n", + " utility = Utility(\n", + " model=SGDClassifier(max_iter=2),\n", + " data=dataset,\n", + " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ "def get_semivalues_and_history(\n", " sampler_t, num_checks=max_checks, num_jobs=n_jobs, progress=True\n", "):\n", @@ -666,9 +1181,84 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Compare convergence speed of both methods\n", "import numpy as np\n", @@ -778,9 +1674,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Similarity of the ranking of Permutation Sampler and MSR Sampler semivalues:\n", + "SignificanceResult(statistic=-0.1956557569612498, pvalue=0.58801436414807)\n" + ] + } + ], "source": [ "from scipy.stats import spearmanr\n", "\n", @@ -800,23 +1705,1466 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "max_checks = [1e3, 2e3, 3e3] if not is_CI else [1, 2]\n", "num_retries = 3 if not is_CI else 2\n", "num_samplers = 5\n", - "twenty_percent = training_data[0].shape[0] // 5\n", - "if is_CI:\n", - " exit(0)" + "twenty_percent = training_data[0].shape[0] // 5" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/20 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Plot results\n", "\n", From 3b7dbb66225e1a44d3d4b39d835e706bde9d5c30 Mon Sep 17 00:00:00 2001 From: jakob1111996 Date: Mon, 8 Apr 2024 09:51:08 +0200 Subject: [PATCH 28/42] reduced runtime of notebook even more --- notebooks/msr_banzhaf_digits.ipynb | 2501 +--------------------------- 1 file changed, 77 insertions(+), 2424 deletions(-) diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb index a22d17dbb..87f8647a5 100644 --- a/notebooks/msr_banzhaf_digits.ipynb +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "tags": [ "hide" @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "tags": [ "hide" @@ -92,20 +92,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/jakob/Documents/pyDVL/src/pydvl/parallel/config.py:31: FutureWarning: The `ParallelConfig` class was deprecated in v0.9.0 and will be removed in v0.10.0\n", - " warnings.warn(\n", - "/home/jakob/Documents/pyDVL/src/pydvl/parallel/config.py:31: FutureWarning: The `ParallelConfig` class was deprecated in v0.9.0 and will be removed in v0.10.0\n", - " warnings.warn(\n" - ] - } - ], + "outputs": [], "source": [ "%autoreload\n", "from pydvl.reporting.plots import plot_shapley\n", @@ -124,7 +113,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -141,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -167,22 +156,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Visualize some of the data\n", "fig, axes = plt.subplots(2, 2, figsize=(4, 4))\n", @@ -204,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -228,18 +204,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train Accuracy: 0.300\n", - "Test Accuracy: 0.081\n" - ] - } - ], + "outputs": [], "source": [ "import torch\n", "from torch import nn, optim\n", @@ -313,84 +280,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - " 0%| | 0/100 [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
data_valuedata_value_stderr
00.00.0
10.00.0
30.00.0
40.00.0
50.00.0
\n", - "" - ], - "text/plain": [ - " data_value data_value_stderr\n", - "0 0.0 0.0\n", - "1 0.0 0.0\n", - "3 0.0 0.0\n", - "4 0.0 0.0\n", - "5 0.0 0.0" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "df.head()" ] @@ -499,7 +322,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -510,20 +333,7 @@ "invertible-output" ] }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABnMAAAIsCAYAAAApsVyuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABVQElEQVR4nO3de5xudV0v8M8XUCyEjaiwVSIwLa+p4CXsaAqRplge0zS1JC3jqAcs06QsFW9USng7Fh5vlAqWiR0xSbygJm4viXcNTRTk4gUBRQGB7/ljrcmHYWbv2bM3M2vPfr9fr+c186z1Xb/1ex5+zJ5Zn+f3W9XdAQAAAAAAYJp2WO0OAAAAAAAAsDhhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAwBJU1dlVdfZmHvOcquqqut9WOP9hY1uHbWlb26qqev34Huy72n0BAICVJMwBAIBtxHgRu1e7H/yYgAUAAFgJO612BwAAALYRB692BwAAgO2TMAcAAGAJuvsrq90HAABg+2SZNQAA2IZV1b7jMl+vr6qfqap/qqrvVNX3qurfqupOY93Nq+r4qjq/qi6vqo9V1f0XaO+WVfUXVfXvVXVBVV1ZVedV1Zuq6g6L9KGq6siq+vzY9jeq6hVVtW5j95mpqt+qqvdV1cXjcV+oqmdV1c4L1N6nqv5fVZ1bVVeMfftIVT17Ce/Rz43v0Rvnbd9vbum6qrrPvH1/OW4/aGbbtV5LVb0/yevGp6+baWvBe7pU1cOr6qNV9YOquqiqTqyqW22q/0tRVQdU1Vur6pvj+/O1qvo/VXWLeXUvGvt3yLztzx23XyewGt/rr2/i/Dca/zt+s6oW/NBgVb1qPMehM9seWlX/UFX/WVWXjY9PVNURVbWkv1er6n5ju89ZZP+qj0EAANhSwhwAAFgb9k2yIcleSV6f5N+S/HKS91fVbZN8JMk9kpyU5C1J7pLkX6tqn3nt3DfJM5NcnOStSf5mPPbhST5aVXdZ4NyvTHJcknVJjk/y5iS/kuTdSW6wUGer6rVJ3pTkNuN5XpnkoiTPS/Ku2UCgqh6Y5P1J/keS9yR5SZKTk1yR5Ekbf1uS7v5Skm8kOWjeroMX+X7u+eVJPryRpl+f5O3j929P8tyZx8Xzap+U5B+SnJ3htX42ySOTnLZQcLA5xnDkw0kekuS0JMcm+VKS/5Xk41W130z5e8avC73eJLn1bBA1hoF7zRy3oO6+PMPYunmSX12gjztneL0XJnnXzK5jkuyfYey+PMkJSW6c5KVJ3rCxc26plRyDAACwpSyzBgAAa8MvJXlWd79gbkNV/XmSozNcKH9Lkid19zXjvndnuHD+h+NjznuT7NXd35ttfAxx/j3Dxfdfndl+nwyhwX8muVd3Xzxu/9MMwcItk3xtXluHJfndJG9L8pju/uHMvuckeXaSJ2e4oJ8kv5/hg2j36+5PzWvrZkt4b+Ze129X1R27+3PjtoOTfDvJueP3zxnbvEmSuyV5/xhSLKi7X19VSfLrSU7u7tdv5PwPTHKP7v7MTN/flOS3xuPfssTXcS1VdeMMocdOGd6fD87s+5MM/73+LkO4lgz/Da/ITJgztnHPDOHbIeO+14y75+reu4TuvD7JE5M8Lsn/m7fv15LcJMmx3X3VzPYHz1++bpyR87okv1NVr+juDUs492ZZpTEIAADLZmYOAACsDWdnuHA/a25mw85Jnj4X5IzelOSqJHedPaC7vzk/yBm3fyrDBf37V9XsbJvHjV9fMBfkjPVXJjlqkb4eOZ778bMX0UfPS/KdJI9Z4Lj5tenuby9yjvkWmpFyUIbXdFqSe1XVLuP2+2f4W2mjs1E208tmg5zRq8ev99yCdn89yR5JTpoNckYvyTAuDpmbgTW+32ck2X8MrZJhNtYNMsyu+lYWnrG0yfeiu8/IEOo9pKr2mLd7bpy8Yd4x11nWbRyncyHKAzZ13mVajTEIAADLZmYOAACsDWd299Xztp03fv3P+QFNd19dVRcm2Xt+Q1X14CSHJ7l7kpvlun833CzJ+eP3dxu/fmiBPn0kwwXz2bZ/MsMSb99O8tRxZst8VyS5/czzNyZ5WJINVXVSkvcl+ffuPnehgxcxN7Pk4CQvG5cP2zNDSHFOkj/OEGr8a368HNtSZqMs1ccX2HbO+PUmC+xbqv3Hr9fpa3dfVVUfyLAE392SfH2m9n7j420ZXu+Pkpye4b09KEmqascM78mXuvu8LM0bkrwgyaOS/J+xnb0yhDKf7O5PzxZX1U2TPD3Jg5LcOskuubatck+heedcrTEIAADLJswBAIC14ZL5G8aL+QvuG12Vefe0qaojM8zQ+G6GZbe+nuQHSTrJQzNcBJ+9x8u68euFC5z/6qr6zrzNN0lSGe6tsqQbx3f3P4/3hXlakscn+YOxr59IclR3v3sJbZxTVWcl+aUxpJidcXJBhjDj4AxhzsFJLk3ysaX0b4kuXmDbXNC14xa0O/f+n7/I/rntu89se0+G5fcOzhDmHJxkQ3dfVlXvSfKbY9i1y9j+GzejPydkmNnyuIxhToYZLjtl3qycqto9w3u8X5KPjsdelOF92T3D7Jktup/QIlZlDAIAwJYQ5gAAAEmS8Ybvz8kQbuzf3efP23/gAoddOn7dK8l/zavfMclNk3xjZvNcsPTJ7t4/S9TdpyQ5ZVwK7V5JDs1wr553VNXduvvzS2jmvRkuwt8jQ4Dxtbllvqrqo0l+uapumeR2Sd6xwEynKZp7P9cvsv8W8+qSITj5fobXe9MMAd3R4765GT6/nOQn523bpO4+t6reO7Z9u+7+YoZg50cZlvab9XsZgpzndvdzZneMY+3IJZ52bvnAxf6+3T3XDtNWcwwCAMCyuGcOAAAw52YZLnx/eIEg58b58ZJesz45fv0fC+z7hcy7wN7d30/yuSR3XOC+KpvU3Zd193u7+4+SvDDJDZP86hIPn7vvywMyLB/2nnn7fj7JI+fVbspc4LMls2u2xNz7f7/5O8Zw7j7j0/+Y297dVyX5QJKfS/LbGWapvGfc9+UMs7EOzrDc2jUZlhTbHK8fvz6uqu6a4X391+7+1ry624xf37pAG7+0Gef77vj1p+bvqKrb5Mezl5Ks+hgEAIBlEeYAAABzvplhSbUDxvAmSVJVN8hwQ/qbLXDMCePXP6uqdTPH3DDDhe6FHJvhAvhrx6W2rqWqblJV+888v+8YTMy31/j1B4u+omt7X4bl4p6U4QL/bGDz3gyhxjNnni/F3DJy+yyxfms7OcPSZL9VVb8wb99TM8x8Oa27vz5v39zrOyrJZRnubzS775eS/GKST3X3RZvZp3/OMGPrsUkOG7e9foG6s8ev95vdWFV3G/u1VF8cz/frVbXnTDs/keRlixyzWmMQAACWxTJrAABAkqS7r6mql2UIND5TVW/PcMH7/kn2yBCG3H/eMadX1fFJnpjkc1X11gxLaj0kw3JW5+XHy2DNHfPaqjogQ6jylao6NcNskD0yhA/3TfK6JIePh7wsya2q6t8zBABXJjkgw8yRryU5cYmv79tV9ekMy4ol1w5szshwQX7PJN9K8pmltDlz3FPHJcsuGLe/vLsXu1fRVtPd36+qxyf5xySnV9U/ZngvD0jyK2N//mCBQ+eCrD2TvKu7fzRv32Hz6janTz8c+/GEDP+Nv5PklAVKT0jy9CTHVdX9k5yV5LYZli/75/x4ltSmzvejqnppkj9P8smqeluGv3UPyTD+zlvgmFUZgwAAsFxm5gAAALP+PMNN3n+YIQR4WJKPJ7lnhovdC/lfSf4ow31YDk/y6CSnZbiYvlt+fF+d/9bdT84Q+JyR4f4sf5Tk1zLMmPnrJMfNlL9wbO+OGe6zcniGGREvTHKP7v5ulm4unPh8d88FL+nuK5N8aHz6vu7upTQ2nvs3knw+QwDyvPFxk83o0xbp7rdnmEXzzgxLyP1xktsn+dskB3T3fy1w2KeSfHv8fv4spPcu8v3meP349QZJ3jy+v/P7fV6GZeBOybBM31OS/HSGgOWZ8+s34dkZZvNcniFYfFCG5dsekCFcvI5VHIMAALDZaol/owAAAGyWqrptkv9McmJ3/9Zq9wcAAGBbZWYOAACwRapqfVXtMG/bT+bHMxvetuKdAgAAWEPcMwcAANhST03yW1X1/iTnJ1mf5OAkeyf51wz3cwEAAGCZhDkAAMCWeneSuyT5lQw3kL8qw/JqL0ty3FLvPwMAAMDC3DMHAAAAAABgwtwzBwAAAAAAYMKEOQAAAAAAABPmnjkrqKoqyS2TfG+1+wIAAAAAAEzCrknO29j9RoU5K+uWSc5d7U4AAAAAAACTsneSbyy2U5izsuZm5Owds3MAAAAAAGB7t2uGSSAbzQyEOavje9196Wp3AgAAAAAAWD3D3Vk2bYfruR8AAAAAAABsAWEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGGTC3Oq6slVdXZVXV5VG6rqnpuof0RVfXGs/0xVPWje/qqqo6vq/Kr6YVWdVlW3nVfzZ1X14ar6QVVdvJFzHVZVnx7P9c2qeuUWvVgAAAAAAIBN2Gm1OzCrqh6Z5NgkhyfZkOSpSU6tqp/r7m8uUH/vJG9OclSSdyR5dJKTq2r/7v7sWPaMJEckeVySryZ53tjmHbr78rHmhkn+MckZSZ6wSN/+KMnTkjx97NsuSfbdwpcMAAAAAABr1r7PPGXHJPdJcosk5yf54NnHPPjq1e3Vtqe6e7X78N+qakOSj3X3U8bnOyQ5J8nLu/uYBepPSrJLdx86s+0jSc7s7sOrqpKcl+Ql3f3icf+6JBcmOay7T5zX3mFJjuvu3edtv0mSbyR5SHe/ZzNez85Jdp7ZtGuSc5Os6+5Ll9oOAAAAAABsa/Z95ikPS/LSJHvPbD43yZFnH/Pgf16dXk1LVe2W5JJsIjeYzDJrVXXDJAckOW1uW3dfMz4/cJHDDpytH506U79fkvXz2rwkw8yaxdpcyCEZ3qtbVdUXqurcqnpLVf3UJo47KsN/hLnHuZtxTgAAAAAA2CaNQc4/JbnVvF23SvJP436WaDJhTpKbJdkxw6yZWRdmCGQWsn4T9etnti21zYXcOsN79acZln57eJI9krx7DKEW86Ik62Yee2+kFgAAAAAAtnnj0movHZ/WvN1zz48b61iCSd0zZ8J2SHKDJEd0978lSVX9VpILktw/w2yg6+juK5JcMfd8WPUNAAAAAADWln2fecpdktxxfHr7bHxyQyX5qSTP2feZp3xh3Pa5s4958Keuxy5u06YU5nw7ydVJ9pq3fa8MoclCLthE/QUz286fV3PmZvRt7tjPz23o7m9V1beT7LMZ7QAAAAAAwFr00iS/tJnHPGvm+9OT3G+r9WaNmcwya919ZZJPJDl4bltV7TA+P2ORw86YrR8dMlP/1QyBzmybuyW510baXMi/j19/bqadPTIsDfe1zWgHAAAAAADWoiOTPGZ8PH+Jxzx/5pgjr6d+rQnV3avdh/9WVY9M8oYkf5DkoxnuT/ObSW7X3RdW1QlJvtHdR431986Q1j0zySlJHpXhvjb7d/dnx5o/Gfc/LkO487wkP5/kDt19+VizT4Z74Pxakqcnuc/YpS939/fHmpOT3CbJE5NcmuF+OLdOctfu/tESX99uSS5Jsq67L938dwgAAAAAAKZtvBfO2UluleveMydJOsm5SfY7+5gHX72CXZucpeYGk5mZkyTdfVKSP05ydIZl0O6a5IHdfeFYsk+SW8zUfzjJozMELJ9K8vAkD50LckZ/leTlSY5P8rEkNx7bvHym5ugkn0zy3HH/J8fH3WdqfifJhgyh0elJfjS2s6QgBwAAAAAAtgdjQDM302b+jJK550/d3oOczTGpmTlrnZk5AAAAAABsL/Z95ikPy3Avnb1nNp+TIcj559Xp1bQsNTcQ5qwgYQ4AAAAAANuTccm1+2RYdev8JB80I+fHhDkTJMwBAAAAAADmbJP3zAEAAAAAAODahDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYMGEOAAAAAADAhAlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAmbZJhTVU+uqrOr6vKq2lBV99xE/SOq6otj/Weq6kHz9ldVHV1V51fVD6vqtKq67byaP6uqD1fVD6rq4k2c76ZVdW5VdVXtvtzXCQAAAAAAsCmTC3Oq6pFJjk3y3CT7J/lUklOras9F6u+d5M1JXpPkbklOTnJyVd1ppuwZSY5IcniSeyW5bGzzRjM1N0zyj0letYRuvibJp5f+qgAAAAAAAJanunu1+3AtVbUhyce6+ynj8x2SnJPk5d19zAL1JyXZpbsPndn2kSRndvfhVVVJzkvyku5+8bh/XZILkxzW3SfOa++wJMd19+6L9O9/JXlkkqOTvCfJTbr74iW+tt2SXJJkXXdfupRjAAAAAACAtWmpucGkZuZU1Q2THJDktLlt3X3N+PzARQ47cLZ+dOpM/X5J1s9r85IkGzbS5mL9u0OSv0jyO0muWUL9zlW129wjya6bcz4AAAAAAIBJhTlJbpZkxwyzZmZdmCGQWcj6TdSvn9m21Davo6p2zrCc29O7++tLPOyoDIna3OPcpZ4PAAAAAAAgmV6YM2UvSvKF7v6HzTxm3cxj7+ujYwAAAAAAwNo1tTDn20muTrLXvO17JblgkWMu2ET9BTPbltrmQg5K8oiquqqqrspwv5wk+XZVPXehA7r7iu6+dO6R5HubcT4AAAAAAIBphTndfWWSTyQ5eG5bVe0wPj9jkcPOmK0fHTJT/9UMoc1sm7sluddG2lzIbyS5S5K7jo/fG7ffJ8krN6MdAAAAAACAJdtptTuwgGOTvKGqPp7ko0memmSXJK9Lkqo6Ick3uvuosf6lSU6vqqclOSXJo5LcPckTk6S7u6qOS/KsqjorQ7jzvCTnJTl57qRVtU+SPZLsk2THqrrruOvL3f397v7KbCer6mbjt1/o7ou30msHAAAAAAC4lsmFOd19UlXdPMnRSdYnOTPJA7v7wrFknyTXzNR/uKoeneT5SV6Y5KwkD+3uz840+1cZAqHjk+ye5ENjm5fP1Byd5HEzzz85fr1/kvdvjdcGAAAAAACwuaq7V7sP241xebdLkqwb76EDAAAAAABsp5aaG0zqnjkAAAAAAABcmzAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwiYZ5lTVk6vq7Kq6vKo2VNU9N1H/iKr64lj/map60Lz9VVVHV9X5VfXDqjqtqm47r+bPqurDVfWDqrp4gXPcpareXFXnjG18oaqO3CovGAAAAAAAYBGTC3Oq6pFJjk3y3CT7J/lUklOras9F6u+d5M1JXpPkbklOTnJyVd1ppuwZSY5IcniSeyW5bGzzRjM1N0zyj0letUjXDkjyzSSPTXLHJC9I8qKqesrmv0oAAAAAAIClqe5e7T5cS1VtSPKx7n7K+HyHJOckeXl3H7NA/UlJdunuQ2e2fSTJmd19eFVVkvOSvKS7XzzuX5fkwiSHdfeJ89o7LMlx3b37Evr6yiS37+6DlvjadktySZJ13X3pUo4BAAAAAADWpqXmBpOamVNVN8wwA+a0uW3dfc34/MBFDjtwtn506kz9fknWz2vzkiQbNtLmUq1LctFiO6tq56rabe6RZNctPB8AAAAAALCdmVSYk+RmSXbMMGtm1oUZApmFrN9E/fqZbUttc5PG5d0emeT4jZQdlSFRm3ucu9zzAQAAAAAA26ephTnbhPF+PG9P8tzu/reNlL4ow+yducfeK9A9AAAAAABgDdlptTswz7eTXJ1kr3nb90pywSLHXLCJ+gtmtp0/r+bMze1gVd0hyXuSHN/dz99YbXdfkeSKmWM393QAAAAAAMB2blIzc7r7yiSfSHLw3Laq2mF8fsYih50xWz86ZKb+qxkCndk2d0tyr420uaCqumOS9yV5Q3f/2eYcCwAAAAAAsBxTm5mTJMcmeUNVfTzJR5M8NckuSV6XJFV1QpJvdPdRY/1Lk5xeVU9LckqSRyW5e5InJkl3d1Udl+RZVXVWhnDneUnOS3Ly3Emrap8keyTZJ8mOVXXXcdeXu/v749Jq701yapJjq2rufjtXd/e3tvJ7AAAAAAAAkGSCYU53n1RVN09ydJL1GZZCe2B3XziW7JPkmpn6D1fVo5M8P8kLk5yV5KHd/dmZZv8qQyB0fJLdk3xobPPymZqjkzxu5vknx6/3T/L+JA9PcvMkjx0fc76WZN9lvVgAAAAAAIBNqO5e7T5sN8bl3S5Jsq67L13t/gAAAAAAAKtnqbnBpO6ZAwAAAAAAwLUJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZskmFOVT25qs6uqsurakNV3XMT9Y+oqi+O9Z+pqgfN219VdXRVnV9VP6yq06rqtvNq/qyqPlxVP6iqixc5zz5VdcpY882q+uuq2mmLXzAAAAAAAMAilh3mjMHG31bVl6rqoqq677j9ZlX1sqq62zLbfWSSY5M8N8n+ST6V5NSq2nOR+nsneXOS1yS5W5KTk5xcVXeaKXtGkiOSHJ7kXkkuG9u80UzNDZP8Y5JXLXKeHZOcMtbdO8njkhyW5OhlvEwAAAAAAIAlqe7e/IOq7pDkgxnCoA1JDklySHe/d9z/H0k+2d1PWEbbG5J8rLufMj7fIck5SV7e3ccsUH9Skl26+9CZbR9JcmZ3H15VleS8JC/p7heP+9cluTDJYd194rz2DktyXHfvPm/7ryZ5R5JbdveF47bDk/xlkpt395VLeG27JbkkybruvnQp7wcAAAAAALA2LTU3WO7MnL9KcnGSn03y2CQ1b/8pSe6zuY1W1Q2THJDktLlt3X3N+PzARQ47cLZ+dOpM/X5J1s9r85IMIdRibS52ns/MBTkz59ktyR0XOqCqdq6q3eYeSXbdjPMBAAAAAAAsO8y5b5JXdfe3kiw0tefrSW61jHZvlmTHDLNmZl2YIZBZyPpN1K+f2bbUNjfnPLPnmO+oDIna3OPczTgfAAAAAADAssOcHZL8YCP7b57kimW2vZa8KMm6mcfeq9sdAAAAAABgW7PcMOc/kjx4oR1VtVOSRyX5yDLa/XaSq5PsNW/7XkkuWOSYCzZRf8HMtqW2uTnnmT3HtXT3Fd196dwjyfc243wAAAAAAADLDnNelOSBVfWqJHcat+1VVb+c5N+S3D7JMZvbaHdfmeQTSQ6e21ZVO4zPz1jksDNm60eHzNR/NUPYMtvmbknutZE2FzvPnatqz3nnuTTJ5zejHQAAAAAAgCXbaTkHdfe/VtVhSV6a5Inj5n9IUhnCjd/p7g8ss0/HJnlDVX08yUeTPDXJLklelyRVdUKSb3T3UWP9S5OcXlVPS3JKhllBd5/rV3d3VR2X5FlVdVaGcOd5Sc5LcvLcSatqnyR7JNknyY5Vdddx15e7+/sZQqrPJ/n7qnpGhvvkPD/JK7vbknIAAAAAAMD1YllhTpJ0999X1T8n+ZUkt8kwy+crSU7t7mUvJ9bdJ1XVzZMcnSEwOTPJA7v7wrFknyTXzNR/uKoenSFYeWGSs5I8tLs/O9PsX2UIhI5PsnuSD41tXj5Tc3SSx808/+T49f5J3t/dV1fVoUlelWGWzmVJ3pDkL5b7WgEAAAAAADalunu1+7DdGJd3uyTJuvEeOgAAAAAAwHZqqbnBsmbmjEuSbVJ3f3057QMAAAAAADBY7jJrZydZypSeHZfZPgAAAAAAAFl+mPP4XDfM2THJvkl+J8k3k7xy+d0CAAAAAAAgWWaY092vX2xfVf1lkg1J1i2zTwAAAAAAAIx22NoNdvdlSV6X5A+3dtsAAAAAAADbm60e5sy0u/56ahsAAAAAAGC7sdx75iyoqnZLct8kT0/yya3ZNgAAAAAAwPZoWWFOVV2TpBfbneTrSZ603E4BAAAAAAAwWO7MnKNz3TCnk3w3yVeS/Ft3X7UlHQMAAAAAACCp7sUm2LC1jcvQXZJkXXdfutr9AQAAAAAAVs9Sc4MdVq5LAAAAAAAAbK4lLbNWVa9dRtvd3U9YxnEAAAAAAACMlnrPnINy3XvkbIr12wAAAAAAALbQksKc7t73eu4HAAAAAAAAC3DPHAAAAAAAgAkT5gAAAAAAAEzYssOcqvrVqnp3VX2nqq6qqqvnP7ZmRwEAAAAAALZHywpzquo3krwjyV5JThzbefP4/Q+TfDrJ0VupjwAAAAAAANut5c7MOSrJR5PcLcmzx22v7e7HJLlTklsk+eqWdw8AAAAAAGD7ttww5w5JTuzuq5NcNW67QZJ099lJ/k+SP9ni3gEAAAAAAGznlhvm/CDJlUnS3RcnuSLDbJw5FybZb4t6BgAAAAAAwLLDnC9lmJ0z58wkv11VO1XVjZI8OsnXt7BvAAAAAAAA273lhjlvS/LrVbXz+PwFSe6X5OIk30pynyTHbGnnAAAAAAAAtnfV3Vunoar7JHlYkquTnNLd79sqDa8hVbVbkkuSrOvuS1e7PwAAAAAAwOpZam6w09Y6YXd/MMkHt1Z7AAAAAAAALHOZtap6S1X9z5ll1gAAAAAAALgeLPeeOb+Y5K1JvllVf19Vh1bVDbZivwAAAAAAAMjyw5y9k9wvyT8kOSTJvyS5sKpeU1W/UlU7bqX+AQAAAAAAbNequ7esgaodktw/yW8m+Z9JbpbkO0ne2t2Hb3EP15Cl3sgIAAAAAABY+5aaG2xxmDPvpDsmeXySFye5cXeboTNDmAMAAAAAAMxZam6w01Y62S2SPCLJI5P8wrj5w1ujbQAAAAAAgO3ZssOcqtozycMzBDi/mOH+Ox9N8sdJ3tLd39gqPQQAAAAAANiOLSvMqar3JLlvkh2TnJnkz5Kc1N1nb7WeAQAAAAAAsOyZOXsmeW6GAOesrdgfAAAAAAAAZiwrzOnuO2/tjgAAAAAAAHBdO6x2BwAAAAAAAFicMAcAAAAAAGDChDkAAAAAAAATJswBAAAAAACYsCWFOVV1bFXdbeb5PlX1E9dftwAAAAAAAEiWPjPnqUluP/P8q0n+51bvDQAAAAAAANey1DDnwiS3nnle10NfAAAAAAAAmGepYc4pSf6iqj5QVf8ybntaVf3LRh5vX26nqurJVXV2VV1eVRuq6p6bqH9EVX1xrP9MVT1o3v6qqqOr6vyq+mFVnVZVt51Xs0dVvbGqLq2qi6vqNVV143k1D6iqj1TV96rqW1X11qrad7mvEwAAAAAAYFOWGuYcmeTFSW6Q5I5JOslPJbnzJh6braoemeTYJM9Nsn+STyU5tar2XKT+3knenOQ1Se6W5OQkJ1fVnWbKnpHkiCSHJ7lXksvGNm80U/PG8bUdkuTQJPdNcvzMefZL8vYk701y1yQPSHKzJP+8nNcJAAAAAACwFNXdm39Q1TVJHtvdb9rqHarakORj3f2U8fkOSc5J8vLuPmaB+pOS7NLdh85s+0iSM7v78KqqJOcleUl3v3jcvy7D0nGHdfeJVXX7JJ9Pco/u/vhY88Ak70yyd3efV1UPzxAa7dzd14w1D8kQ8Ozc3T9aoG87J9l5ZtOuSc5Nsq67L92CtwkAAAAAANjGVdVuSS7JJnKDpc7Mme/+Sd69zGMXVVU3THJAktPmto3ByWlJDlzksANn60enztTvl2T9vDYvSbJhpubAJBfPBTmj05Jck2EmT5J8Ynz+u1W14xgI/XaS0xYKckZHZfiPMPc4d5E6AAAAAACABS0rzOnu07v7W1u7MxmWLdsxw6yZWRdmCGQWsn4T9etntm2s5puzO7v7qiQXzdV091eT/EqSFya5IsnFSfZO8psbeT0vSrJu5rH3RmoBAAAAAACuY6flHlhVP5/kf2e4r826XDcY6u7+mS3o26RU1fokr07yhgzLre2a5Ogk/1RVh/QC69V19xUZgp+5NlaotwAAAAAAwFqxrJk5VXW/JB9NcmiG+9HcOsl/jd//dJLvJ/nAMpr+dpKrk+w1b/teSS5Y5JgLNlF/wcy2jdXsObuzqnZKssdMzZOTXNLdz+juT3b3B5I8NsnB+fFSbAAAAAAAAFvVcu+Zc3SG8ObnkvzuuO2F3f0/ktw7w3Jib9ncRrv7ygz3pjl4bltV7TA+P2ORw86YrR8dMlP/1QyBzGybu2UIYOZqzkiye1UdMNPGQRnenw3j85/McM+cWVePX5f7PgIAAAAAAGzUckOI/ZO8prsvzY8DjR2TpLs3JPm7JM9bZtvHJvn9qnpcVd0+yauS7JLkdUlSVSdU1Ytm6l+a5IFV9bSqul1VPSfJ3ZO8YuxPJzkuybOq6teq6s5JTsgwi+jkseYLSd6V5NVVdc+q+sXx+BO7+7zxPKckuUdV/UVV3baq9h/79LUkn1zmawUAAAAAANio5d4z56ok3xu/vzjJj3LtZcr+K8kdltNwd59UVTfPMPtnfZIzkzywuy8cS/bJzAyZ7v5wVT06yfOTvDDJWUke2t2fnWn2rzIEQscn2T3Jh8Y2L5+peUyGAOc9Y/tvTXLEzHneO57nGePjBxlm9Dywu3+4nNcKAAAAAACwKTVMXNnMg6o+nuR93f308fmnkpzV3Q8fn5+c5Oe7+9Zbsa/bvHF5t0uSrBtnNQEAAAAAANuppeYGy11m7Z1Jfquq5mb2HJvkYVV1VlWdleTXMiy1BgAAAAAAwBZY7sycGyTZLclF4z1pUlWPTfIbGe6h847ufv1W7OeaYGYOAAAAAAAwZ6m5wbLCHJZHmAMAAAAAAMy5vpdZAwAAAAAAYAXstOmShVXVA5I8Icmtk9wkSc0r6e7+mS3oGwAAAAAAwHZvWWFOVT09yTFJLkzy0SSf2ZqdAgAAAAAAYLDcmTlHJnlvkgd194+2Yn8AAAAAAACYsdx75twkyT8JcgAAAAAAAK5fyw1zPprk57ZmRwAAAAAAALiu5YY5T0rysKp69NbsDAAAAAAAANdW3b3poqpPL7B5jyS3SPL9JOcmuXre/u7uu2xxD9eQqtotySVJ1nX3pavdHwAAAAAAYPUsNTfYaYntXZRkfurznSRnLa97AAAAAAAALMWSwpzuvt/13A8AAAAAAAAWsNx75gAAAAAAALAClhXmVNU1VXV+Vd13kf2Pqar599ABAAAAAABgM23JzJwbJTmtqo7cWp0BAAAAAADg2rYkzHlqklcn+Zuq+vuqutHW6RIAAAAAAABztiTM+VF3PznJYUkeluTfq2qfrdIrAAAAAAAAkmxZmJMk6e4Tkvxikt2TfKKqDt7SNgEAAAAAABhscZiTJN19ZpIDknwsybuSPGFrtAsAAAAAALC92yphTpJ098VJHpzkhUl+aWu1CwAAAAAAsD3baZnH7ZfkW/M3dncneXZV/WOSm25JxwAAAAAAAFhmmNPdX9vE/s8urzsAAAAAAADMWu7MnFTVTZL8VpJbJ7lJkppX0t3t3jkAAAAAAABbYFlhTlU9IMk/JdklyaVJvrtAWW9BvwAAAAAAAMjyZ+a8JMkFSR7W3Z/Ziv0BAAAAAABgxg7LPO42SV4myAEAAAAAALh+LTfMOSvJrluzIwAAAAAAAFzXcsOcZyV5UlXtuxX7AgAAAAAAwDzLvWfOwUm+leQLVfXuJOckuXpeTXf3kVvSOQAAAAAAgO1ddffmH1R1zRLKurt33PwurV1VtVuSS5Ks6+5LV7s/AAAAAADA6llqbrCsmTndvdzl2QAAAAAAANgMQhkAAAAAAIAJE+YAAAAAAABM2LLDnKr61ap6d1V9p6quqqqr5z+2ZkcBAAAAAAC2R8sKc6rqN5K8I8leSU4c23nz+P0Pk3w6ydFbqY8AAAAAAADbreXOzDkqyUeT3C3Js8dtr+3uxyS5U5JbJPnqlncPAAAAAABg+7bcMOcOSU7s7quTXDVuu0GSdPfZSf5Pkj/Z4t4BAAAAAABs55Yb5vwgyZVJ0t0XJ7kiw2ycORcm2W+LegYAAAAAAMCyw5wvZZidM+fMJL9dVTtV1Y2SPDrJ17ewbwAAAAAAANu95YY5b0vy61W18/j8BUnul+TiJN9Kcp8kx2xp5wAAAAAAALZ3ywpzuvvF3b1Pd18xPn9HhjDn1Un+LsnB3f365Xaqqp5cVWdX1eVVtaGq7rmJ+kdU1RfH+s9U1YPm7a+qOrqqzq+qH1bVaVV123k1e1TVG6vq0qq6uKpeU1U3XqCdP66q/6yqK6rqG1X1Z8t9nQAAAAAAAJuy3Jk519HdH+zuP+zuP+7u9y23nap6ZJJjkzw3yf5JPpXk1Krac5H6eyd5c5LXJLlbkpOTnFxVd5ope0aSI5IcnuReSS4b27zRTM0bk9wxySFJDk1y3yTHzzvdS5P8XpI/TnK7JL+W5KPLfKkAAAAAAACbVN295Y1U7ZTktklunOQL3f39LWhrQ5KPdfdTxuc7JDknycu7+zpLt1XVSUl26e5DZ7Z9JMmZ3X14VVWS85K8pLtfPO5fl+TCJId194lVdfskn09yj+7++FjzwCTvTLJ3d5831nw6yZ26+0vLfG27JbkkybruvnQ5bQAAAAAAAGvDUnODzZqZU1UPqqq/r6rXVdVB47aHJjk7yWeTfCTJt6rq+cvs9A2THJDktLlt3X3N+PzARQ47cLZ+dOpM/X5J1s9r85IkG2ZqDkxy8VyQMzotyTUZZvIkyUOS/FeSQ6vqq+MycP+3qvbYyOvZuap2m3sk2XWxWgAAAAAAgIXstNTCcabKO5L8KMkPkzy2qh6fYXmzzyf5x7G9ByQ5qqq+1t2v3sz+3CzJjhlmzcy6MMOyZgtZv0j9+pn9WULNN2d3dvdVVXXRTM2tk/x0kkck+Z2xn3+T5J+SHLRI345K8uxF9gEAAAAAAGzSksOcDPed+WyS+3b3xVX1t0n+Lsm7kxza43pt45JrH8lwf5rNDXOmbIckOyf5ne7+zySpqick+URV/dwiS6+9KMP9f+bsmuTc672nAAAAAADAmrE5y6zdMcnru/vi8fnLktwoyT/0zI13uvuqJG/M4jNpNubbSa5Oste87XsluWCRYy7YRP0FM9s2VrPn7M4xlNpjpub8JFfNBTmjL4xf91moY919RXdfOvdI8r1FXgMAAAAAAMCCNifMuXmuvVTZ3LJk85cvm9t3o83tTHdfmeQTSQ6e21ZVO4zPz1jksDNm60eHzNR/NUMgM9vmbhnuhTNXc0aS3avqgJk2Dsrw/mwYn/97kp2q6mdman52/Pq1Tb02AAAAAACA5dicZdaSpBf5fms6NskbqurjST6a5KlJdknyuiSpqhOSfKO7jxrrX5rk9Kp6WpJTkjwqyd2TPDFJurur6rgkz6qqszKEO89Lcl6Sk8eaL1TVu5K8uqoOT3KDJK9IcmJ3nzee57Qk/5HktVX11AxBzyuTvHvebB0AAAAAAICtZnPDnH2rav/x+3Xj19tW1cXz6vZbboe6+6SqunmSo5OsT3Jmkgd299wMoH2SXDNT/+GqenSS5yd5YZKzkjy0uz870+xfZQiEjk+ye5IPjW1ePlPzmAwBznvG9t+a5IiZ81xTVQ9J8vIkH0hyWZJ/TfK05b5WAAAAAACATamZ291svLDqmlx3Nk4tsO2/t3f3jlvWvbVlXN7tkiTrxnvoAAAAAAAA26ml5gabMzPnd7e4VwAAAAAAAGyWJYc53f2G67MjAAAAAAAAXNcOq90BAAAAAAAAFifMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwiYZ5lTVk6vq7Kq6vKo2VNU9N1H/iKr64lj/map60Lz9VVVHV9X5VfXDqjqtqm47r2aPqnpjVV1aVRdX1Wuq6saLnO82VfW9qrp4i18sAAAAAADARkwuzKmqRyY5Nslzk+yf5FNJTq2qPRepv3eSNyd5TZK7JTk5yclVdaeZsmckOSLJ4UnuleSysc0bzdS8MckdkxyS5NAk901y/ALnu8F4vg8u+0UCAAAAAAAsUXX3avfhWqpqQ5KPdfdTxuc7JDknycu7+5gF6k9Kskt3Hzqz7SNJzuzuw6uqkpyX5CXd/eJx/7okFyY5rLtPrKrbJ/l8knt098fHmgcmeWeSvbv7vJm2/zLJLZO8J8lx3b37Zry23ZJckmRdd1+65DcFAAAAAABYc5aaG0xqZk5V3TDJAUlOm9vW3deMzw9c5LADZ+tHp87U75dk/bw2L0myYabmwCQXzwU5o9OSXJNhJs9c/w5K8ogkT17i69m5qnabeyTZdSnHAQAAAAAAzJlUmJPkZkl2zDBrZtaFGQKZhazfRP36mW0bq/nm7M7uvirJRXM1VXXTJK/PMJtnqbNqjsqQqM09zl3icQAAAAAAAEmmF+ZM2auTvKm7P7AZx7woybqZx97XR8cAAAAAAIC1a2phzreTXJ1kr3nb90pywSLHXLCJ+gtmtm2sZs/ZnVW1U5I9ZmoOSvLHVXVVVV2V5DVJ1o3PH79Qx7r7iu6+dO6R5HuLvAYAAAAAAIAFTSrM6e4rk3wiycFz26pqh/H5GYscdsZs/eiQmfqvZghkZtvcLcO9cOZqzkiye1UdMNPGQRnenw3j8wOT3HXm8RcZwpm7JnnbUl4fAAAAAADA5tpptTuwgGOTvKGqPp7ko0memmSXJK9Lkqo6Ick3uvuosf6lSU6vqqclOSXJo5LcPckTk6S7u6qOS/KsqjorQ7jzvCTnJTl5rPlCVb0ryaur6vAkN0jyiiQndvd5czWznayquye5prs/ez28BwAAAAAAAEkmGOZ090lVdfMkRydZn+TMJA/s7gvHkn2SXDNT/+GqenSS5yd5YZKzkjx0XsjyVxkCoeOT7J7kQ2Obl8/UPCZDgPOesf23Jjlia78+AAAAAACAzVHdvdp92G6My7tdkmTdeA8dAAAAAABgO7XU3GBS98wBAAAAAADg2oQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEzbJMKeqnlxVZ1fV5VW1oaruuYn6R1TVF8f6z1TVg+btr6o6uqrOr6ofVtVpVXXbeTV7VNUbq+rSqrq4ql5TVTee2X+/qnr72MZlVXVmVT1m675yAAAAAACAa5tcmFNVj0xybJLnJtk/yaeSnFpVey5Sf+8kb07ymiR3S3JykpOr6k4zZc9IckSSw5PcK8llY5s3mql5Y5I7JjkkyaFJ7pvk+Jn9907y6SS/keTnk7wuyQlVdegWvFwAAAAAAICNqu5e7T5cS1VtSPKx7n7K+HyHJOckeXl3H7NA/UlJdunuQ2e2fSTJmd19eFVVkvOSvKS7XzzuX5fkwiSHdfeJVXX7JJ9Pco/u/vhY88Ak70yyd3eft0hfT0lyYXc/fomvbbcklyRZ192XLuUYAAAAAABgbVpqbjCpmTlVdcMkByQ5bW5bd18zPj9wkcMOnK0fnTpTv1+S9fPavCTJhpmaA5NcPBfkjE5Lck2GmTyLWZfkoo28np2rare5R5JdN9IWAAAAAADAdUwqzElysyQ7Zpg1M+vCDIHMQtZvon79zLaN1Xxzdmd3X5UhqFnwvFX1m0nukWG5tcUclSFRm3ucu5FaAAAAAACA65hamLNNqKr7Zwhxfr+7P7eR0hdlmL0z99h7BboHAAAAAACsITutdgfm+XaSq5PsNW/7XkkuWOSYCzZRf8HMtvPn1Zw5U7PnbANVtVOSPeaft6p+Kcn/S/KH3X3C4i8l6e4rklwxc+zGygEAAAAAAK5jUjNzuvvKJJ9IcvDctqraYXx+xiKHnTFbPzpkpv6rGQKZ2TZ3y3AvnLmaM5LsXlUHzLRxUIb3Z8PMcfdLckqSP+nu45f+ygAAAAAAAJZnajNzkuTYJG+oqo8n+WiSpybZJeO9aarqhCTf6O6jxvqXJjm9qp6WIWh5VJK7J3liknR3V9VxSZ5VVWdlCHeel+S8JCePNV+oqncleXVVHZ7kBklekeTE7j5vPO/9k7xjPN9bq2ruXjpXdvdF189bAQAAAAAAbO8mF+Z090lVdfMkRydZn2EptAd294VjyT5Jrpmp/3BVPTrJ85O8MMlZSR7a3Z+dafavMgRCxyfZPcmHxjYvn6l5TIYA5z1j+29NcsTM/scl+ckkR42POacnud+yXzAAAAAAAMBGVHevdh+2G+PybpckWdfdl652fwAAAAAAgNWz1NxgUvfMAQAAAAAA4NqEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmTJgDAAAAAAAwYcIcAAAAAACACRPmAAAAAAAATJgwBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmTJgDAAAAAAAwYcIcAAAAAACACRPmAAAAAAAATJgwBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmTJgDAAAAAAAwYcIcAAAAAACACRPmAAAAAAAATJgwBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmTJgDAAAAAAAwYcIcAAAAAACACRPmAAAAAAAATJgwBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmTJgDAAAAAAAwYcIcAAAAAACACRPmAAAAAAAATJgwBwAAAAAAYMJ2Wu0OsH3b95mn7JjkPklukeT8JB88+5gHX726vWItM+ZYScYbK82YYyUZb6w0Y46VZsyxkow3VpoxB9ueSc7MqaonV9XZVXV5VW2oqntuov4RVfXFsf4zVfWgefurqo6uqvOr6odVdVpV3XZezR5V9caqurSqLq6q11TVjefV/HxVfXA8zzlV9Yyt96q3P/s+85SHJTk7yfuSvGn8eva4HbY6Y46VZLyx0ow5VpLxxkoz5lhpxhwryXhjpRlzsG2aXJhTVY9McmyS5ybZP8mnkpxaVXsuUn/vJG9O8pokd0tycpKTq+pOM2XPSHJEksOT3CvJZWObN5qpeWOSOyY5JMmhSe6b5PiZ8+yW5N+SfC3JAUmenuQ5VfXELXvF26fxH4d/SnKrebtuleSf/OPB1mbMsZKMN1aaMcdKMt5YacYcK82YYyUZb6w0Yw62XdXdq92Ha6mqDUk+1t1PGZ/vkOScJC/v7mMWqD8pyS7dfejMto8kObO7D6+qSnJekpd094vH/euSXJjksO4+sapun+TzSe7R3R8fax6Y5J1J9u7u86rqfyV5QZL13X3lWHNMkod29+2W+Np2S3JJknXdfenmvztrwziN8+wM/0jUAiWd5Nwk+5neydZgzLGSjDdWmjHHSjLeWGnGHCvNmGMlGW+sNGMOpmmpucGkwpyqumGSHyR5eHefPLP9DUl27+5fX+CYryc5truPm9n23Awhy12q6tZJvpLkbt195kzN6RkCnyOr6vEZwp6bzOzfKcnlSR7R3W+rqhOS7NbdD52puX+S9ybZo7u/u0Dfdk6y88ymXTP8QNzuwpx9n3nKXTLMfEqS2yd51hIOe36SL4zff+7sYx78qeujb6xNxhwryXhjpRlzrCTjjZVmzLHSjDlWkvHGSjPmYPqWGubstHJdWpKbJdkxw6yZWRcmWWz2y/pF6tfP7M8Sar45u7O7r6qqi+bVfHWBNub2XSfMSXJUkmcv0u/tzUuT/NJmHjP7j8vpSe631XrD9sCYYyUZb6w0Y46VZLyx0ow5Vpoxx0oy3lhpxhysEVMLc9aaF2W4/8+cuZk526Mjs4WfArg+OsWaZsyxkow3Vpoxx0oy3lhpxhwrzZhjJRlvrDRjDtYIy6xdj8usLdBX98yJ9TlZecYcK8l4Y6UZc6wk442VZsyx0ow5VpLxxkoz5mCalpob7LByXdq07r4yySeSHDy3rap2GJ+fschhZ8zWjw6Zqf9qkgvmtblbknvN1JyRZPeqOmCmjYMyvD8bZmruW1U3mHeeLy0lyOHHxn8Mjhyfzk8T554/1T8abC3GHCvJeGOlGXOsJOONlWbMsdKMOVaS8cZKM+Zg2zapMGd0bJLfr6rHVdXtk7wqyS5JXpckVXVCVb1opv6lSR5YVU+rqttV1XOS3D3JK5Kkh6lHxyV5VlX9WlXdOckJSc5LcvJY84Uk70ry6qq6Z1X94nj8id193nieNyW5MslrquqOVfXIDD/8ZpdRY4nOPubB/5zk4Um+MW/XuUkePu6HrcaYYyUZb6w0Y46VZLyx0ow5Vpoxx0oy3lhpxhxsuya1zNqcqnpKkqcnWZ/kzCRHdPeGcd/7k5zd3YfN1D8iw1qO+yY5K8kzuvudM/sryXOTPDHJ7kk+lORJ3f2fMzV7ZAhwHpLkmiRvHc/7/Zman0/yyiT3SPLtJC/v7r/cjNdlmbV5xumd90lyiyTnJ/mg9J/rkzHHSjLeWGnGHCvJeGOlGXOsNGOOlWS8sdKMOZiOpeYGkwxz1iphDgAAAAAAMGebvGcOAAAAAAAA1ybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhwhwAAAAAAIAJE+YAAAAAAABMmDAHAAAAAABgwoQ5AAAAAAAAEybMAQAAAAAAmDBhDgAAAAAAwIQJcwAAAAAAACZMmAMAAAAAADBhO612B7ZTu1bVavcBAAAAAABYXbsupUiYs7Lm/qOcu6q9AAAAAAAApmTXJJcutrO6ewX7sn2rYTrOLZN8b7X7MjG7Zgi49o73hpVhzLGSjDdWmjHHSjLeWGnGHCvNmGMlGW+sNGOOlWS8bdyuSc7rjQQ2ZuasoPE/xDdWux9TM7Pk3Pe6e9HkEbYWY46VZLyx0ow5VpLxxkoz5lhpxhwryXhjpRlzrCTjbZM2+Z7ssBK9AAAAAAAAYHmEOQAAAAAAABMmzGEKrkjy3PErrARjjpVkvLHSjDlWkvHGSjPmWGnGHCvJeGOlGXOsJONtC9VG7qcDAAAAAADAKjMzBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAALZhVVWr3QcAAADg+iXMYdW4+AQAW667u6r8TgcAsI2Zuy7i+ggryXiDbZc//Fk13d2r3Qe2D35RYaUZc6yEqnpYVf1pVd2wu68Zt/ndjutNVd2yqn5itfvB9qOqfraqDqqqHVe7L2wfquoJVfVGY44V9JNVtfPc9RF/R7ASXI/j+uZn2fWn/P/LSqqqOyU5OMnNk5yX5J1Jvtvdl6xqxwC2gqo6IMmjktwyyWnd/bpV7hJr1BjafCfJuiQfTvKy7n7LzP7yRxpbU1XtlOTcJP8rycnGF9e38WL6aUkuTfKs7v7MKneJNW4cc99McpMkxyb58+7+oX9TuT6MFzoPS/KEJHsneUN3P3tVO8WaVlW3SHL/DH8/fDfJKUmu7O4rVrVjrFlVtXuShyS5cZKvdve7VrdHa8NOq90Bth9VdVSGCwB7Z7gAtVuSFyR5W1W9JckZQh22pqo6NMmVST7c3d9f7f6wtlXVHyV5coYg57tJfrOq7pDkmRk+/HTNavaPNeeWGS44JcnOSf62qh6R5Jju/sTMpzt3MPbYSo7NMKv/XBc1WSEvSXLrJH80G+RU1R7dfZEL7FwPXpHxb4ck/zvJZzJcYDfOuD48O8nvJflekq8m+fOqurq7j17dbrEWVdURSY7I8O9qJ6kkX0/yhqo6NcmnuvuyVewia0xVPT7JHya547jpovHa77O7+1ur17Ntn5k5rIiq2i/JF5P8bZJjktwgyU8neVCSPxjL/jbJq7v7q/44Y0tV1b5J/mt8vD7JPyf5z+6+atxvjLHVVNWtk3wiyYlJjs7wYYkTk/xEkl/KcGFgN7+0sDVV1W8l+bMMF9n/R4ZPPV2Z5M1JXtzdF1TVMUlO6O7Pr15P2dZV1W2S/GeSpyU5vrsvq6p1SX4hyX5Jdk9yYnefvWqdZE0ZPz38qQyBzqu6+9KqenCSh2X4d/VbSf5fhpk7n+zuH61aZ1kTqupnkpyV4cOH70jy6gwrShye5IT4YA5b0Xh95HNJ/ibJXyX5UZI3Jrk6Q8Czf4afc19Pcqm/W9kS49+qn03yLxk+UH2jJA9N8qQMs3Q+neS1GX7Hu9y1ErbU+DPujAwfjnhJhg8fPjXJA5I8pbtfvXq92/YJc1gRVfXnSR6b5NDuPmvevn2S/HmS303yniS/090XrnwvWUuq6q+TPCXJJ5PcK8MFgVckeXd3nzNT5xcVtlhV/VOSn0ryuO7+4rjtyUn+JMmHktw0yS9muOh0dHf/x2r1lbVjnLZ+apKPdPeR48ycP0hy9wzLYZ2V4UMT+3f358zSYbmq6l0Zlh16ZHefPV5of2OS+80rfWWSI40ztlRV/UKSk5L87+7+lzFQ/GSSizJ8QGyXDL/ffTnJn3b321ats6wJVfXuJLsmeUx3f6Wq7pfhwxHfS/KQ7v7SKnaPNaaqXpzh39DHzvzt8D8zfEjn5kn2yPBz7vQkL+ju01apq6wBVXV8kntm+D3uSzPbH5Pk7zOEhvtk+HD1HyzcCixdVZ2U4QP8h839jBu3n5zh97e7dfcFq9S9bZ6b5LJSLsqwJMxOSVJVN5zb0d1f7+7fT/KYJHdJcmpV/dSq9JI1oarWZ7hwflaSQzOk/1dk+ITd/6mqB1fVHsmPb/xXVXtV1S6r1GW2YeO9wA7IcNFpNqy+e5L1Sb6d5K1J/jrJXZO8r6ruvcLdZA3q7ouT/FGSX6+qe3b3Pyb5jSTPGUsenGH83X6sd4GdzVZVv5zkVzLc53BuOdzXJ/nZJEdl+OP/UUnekGGpyVOr6qYr31PWmO9m+JDEnFcm+XySB3X3AzL8bnfwWHdiVf1K4ma7LM846+vgDJ8ePjtJuvv9SX4tyU8mecd4X0RjjK3lhhmujZw9s+0hSe6Q4eL6IzP8m3rTJP9SVQ9JjD8233gvsBsluXwuyKmqncfdb0/yH0lek+Faye9X1QtXpaOsGeOsnNsn+bckXxm3zV0Dfm2SvTKsKjF3H9hU1U+sfE+3XcIcVsp/Zvhl5deTpLuvrKod5/0y8vYkz8qwnuKvrnwXWUM6yY5JTu/ui5K8N8On04/IEBiemOToqjqwqnaoqhtkuK/JR8ZlY2Bz/ESGTwZ/pbuvTv474HlckqcneUZ3H59hKaxnZPjU56NWqa+sIeMfZx/PcIHzb6tqfXdf0t3HZZiNeGWGn4evrqq3zPzhBptjzwwXzI9IcnhV/V6S+2a4n8RLuvvc7n5Lhp9vL89wQfQXV6uzrBlfS/KRJI8ef09LkpO7+3Pj9z/o7g9kWBLrWxlm+P/3h3RgMz0uwwX007v76vHvgx0yzAZ7fpKfSfKsqrpxd7cL6mwF30vy80nuXlU3qarfzbCSydMy3E/inUlelyHQuWz86mccm238+/TiJHcdL7Knu6+oqp0y/K1wiwz/5j4pwwd3Hj8uWQ/LtVuSmyU5p7t/NK6Gc2WSdPe/ZLg+PHdt+Jrx97w/qKoNVfWTq9brbYhl1lgxVfU3SY7MsC7s0d19ybh9xyTXzMyQ+HiGT6j8pk8Rs1xVtWuSdPf35m3fN8MFqMMz/PH/8iTfyXAvp3/v7t9Y2Z6yrRt/ht25u8+c2fb4DNOHj5p/k+aq+mSSczKs+3+1P8rYUuPyQ6ckeU53v7mq9k+yIUOY+NkMF9k/3d1/vIrdZBs1/oy7TYZ1rg/LsOb1KRmWTfjO7O9x4x9jl2S4x8nTVqnLrBHjv6X/N8k/ZLhh89e6+zHzl8gdb6a7X4YZZBf7d5XNVVU3SbJrd399kf1/mGGG9ZuTHO4m4Wypqtozw/1L7pnkB0kuz/BhxEO6++Pz/nZ4W4afcQ+wHD3LMX7Q8AMZ7tN0XIb7Cd80w98Ih2dY8uorVXW7JGcmeXx3v2l1esu2bpxl86wkf9/dX5z7eTa35HdVvSBDePgz47WSO2RYyeTL3f2Q1ez7tmKn1e4A25XnZLhB7u8muUNVvaq7/2Xu009JepwVcW6Gf1h2SCLMYVnmhzgz28+uqqcneUuGC50vyvDL805JHr9yPWStGD/tdOa8ba+tqrd193fHTZXhZ9z6DH+wXTPWueDEFhl/Of5yVb0jybFV9bEM4fRnMnyK/eyqek+GCwSw2cafcV+qqiMyzGz9gyTf7e7vzO2f+ZT6rZKcl+Qn3JOOreD1GWZEHJnh39E9quqg7n7vzAWB3ZP8MMOSRT8w5liO8fe1787fPnOvueMzjMUnJflyVT1/bjY2LEd3f7OqfjPJb2ZYrvTLSe6cYRZOMlwLuXr8GXdNhpnWlyzQFGxSd3+2qg7NcK/Nv0/y4iQ3yHArhP+dYWZOMoyzb2e4ZxMsS3f/MMmfzc2snvvdbObD+qdmWKr5wKp6b5LfzvChnV9Yhe5ukyyzxooZZ+I8IcMyHXdP8qqqenNV/cr4x9geGZbCuk+Sd3b3VavYXdaw7r6muzdkuE/TK5LcOMMMCr8gs8XmLmrOBDmzv7jcMcntkpzmZxxbw8yFy5ck+WaGi5/3yxDonDNT46ITW6S7f9Tdpyd5SoZlh/57neuZcfizGS4A/IeL6myp8d/OP0/yexk+eHO7JP9QVX+U5M5Vddskv5/kfyZ5U3dfsWqdZU2a+/1tnInz7AxLEP1JhlmK7l/CFhnvHfzi7j6iu1+WYdWId1bVvWbCwoMyLG365u6+fNU6yzavuz+c5CYZPiDxqQw/z367u18583fpT2f4cMS3V6eXrCXd/aNFdm3I8OGvB2S4p/DhSZ7netzSWWaNVVFVuyX5iwyfRLlVkgszfKpujyQf7eHGpnC9mJnmedskf5dk3+6+9Wr3i7Vp5tPDd03y3CR37O7brHK3WIOq6rcz3CT8X5McYSkOVsLMz7g7J3lehmUnf2a1+8XaMi6f+6dJnpjhYtSVGT6tflWGD0g8bBW7xxo387fDTZO8P8kNuvt2q9wt1piqumOSt2X40PXHMsxIPDjJ57v7l1azb6wtVbXj/NmF49+qz0xyQHffdlU6xpo38+/p/03y4AxLgt+uu39qlbu2TRHmsKrGJYd+NcOU4j2SvD3JR7r7/FXtGGve+Em6xyZ5Q5KHjjdig+tFVe2d5LUZPlX8+O4+bZW7xBo1rjn8o+4+a7X7wvajqm6V5G8zrP3/O9196ip3iTWqqvbKcG+c2yVZl+QdST7R3d9a1Y6x3aiqX01y0TjLH7aqqrp1hg/m3CvDPer+Nsn/7e4vrGrHWNOqaucMy9AfmOSx3f1vq9wl1qiZMOdBGcLrGyT5te5+xyp3bZsizAG2W1V1wySP6O43rnZfWNuq6mczLBXzb93996vdH4CtaQwR/ybJO7r75avdHwDYlo3B9U7d/Y3V7gtr3xjm3DvJLi6qsxLG+6WfluTs7n7EavdnWyPMAYAVMM4Gq5n75wCsGeP9c3ZwPzAAAGBjqmqnJD/R3d9b7b5sa4Q5AAAAAAAAE7bDancAAAAAAACAxQlzAAAAAAAAJkyYAwAAAAAAMGHCHAAAAAAAgAkT5gAAAAAAAEyYMAcAAAAAAGDChDkAAAAAAAATJswBAACYp6oOq6quqruvdl8AAACEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAMAmVNXrq+r7VbVPVb1j/P4bVfXkcf+dq+q9VXVZVX2tqh497/g9qurFVfWZ8dhLq+pfq+ouC5zrp6vqX8a2vllVf1NVDxiXfbvfvNp7VdW7quqSqvpBVZ1eVb94fb4XAADAyhPmAAAALM2OSf41yTlJnpHk7CSvqKrDkrwryceT/EmS7yU5oar2mzn21kkemuQdSf4oyV8nuXOS06vqlnNFVbVLkvcm+eUkL0vygiT3TvKX8ztTVQcl+UCS3ZI8N8mfJtk9yXur6p5b5RUDAACTsNNqdwAAAGAbcaMk/9DdL0qSqnpTkvOSvDbJb3X3SeP2dyf5YpLHJXnOeOxnkvxsd18z11hV/f1Y94Qkzxs3/0HG4Ke73z7W/V2ST852pKoqyd8meV+SX+3unqn9XJLnJ/mVrfjaAQCAVWRmDgAAwNL937lvuvviJF9KclmSt8xs/1KSizOEMnPbrpgLcqpqx6q6aZLvj8fvP9P+A5N8I8m/zBx7eZJXz+vHXZPcNsmbkty0qm5WVTdLskuS9yS5b1X5ew8AANYIM3MAAACW5vLu/ta8bZckOXduZsy87TeZezIGK0cmeVKS/TIs2TbnOzPf/3SSryzQ3pfnPb/t+PUNG+nvuiTf3ch+AABgGyHMAQAAWJqrN3N7zXz/pxmWUnttkj9PclGSa5Icl+WtmDB3zNOTnLlIzfeX0S4AADBBwhwAAIDr38OTvK+7nzC7sap2T/LtmU1fS3KHqqp5s3NuM6+9r4xfL+3u07Z2ZwEAgGmxhjIAAMD17+pce6ZOquoRSW41r+7UcduvzdTdKMnvz6v7RIZA54+r6sbzT1ZVN98KfQYAACbCzBwAAIDr3zuS/EVVvS7Jh5PcOcljkvzXvLq/S/KUJG+uqpcmOX+su3zc30nS3ddU1e8l+dcknxvb/UaGIOj+SS5N8pDr9RUBAAArRpgDAABw/Xthkl2SPDrJI5P8R5IHJzlmtqi7v19VByV5eZIjM9z35oQMAdBb8+NQJ939/qo6MMM9eJ6S5MZJLkiyIUMoBAAArBF17WWYAQAAmJqqemqSv0myd3d/Y5W7AwAArDBhDgAAwIRU1U909w9nnt8oySeT7NjdP7t6PQMAAFaLZdYAAACm5Z+r6utJzkyyLsljk9wuw71zAACA7ZAwBwAAYFpOTfJ7GcKbHZN8PsmjuvukVe0VAACwaiyzBgAAAAAAMGE7rHYHAAAAAAAAWJwwBwAAAAAAYMKEOQAAAAAAABMmzAEAAAAAAJgwYQ4AAAAAAMCECXMAAAAAAAAmTJgDAAAAAAAwYcIcAAAAAACACfv/Mk1r2MIXy7AAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "low_dvl = df.iloc[:30].copy()\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -550,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "editable": true, "slideshow": { @@ -561,27 +371,7 @@ "invertible-output" ] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Average value of first 10 data points: 0.00015914351851851853\n", - "Exact values:\n", - "0 0.000000\n", - "1 0.000000\n", - "3 0.000000\n", - "4 0.000000\n", - "5 0.000000\n", - "6 0.000000\n", - "7 0.000000\n", - "8 0.000000\n", - "9 0.000000\n", - "2 0.001591\n", - "Name: data_value, dtype: float64\n" - ] - } - ], + "outputs": [], "source": [ "high_dvl = df.iloc[-10:].copy()\n", "print(f\"Average value of first 10 data points: {high_dvl['data_value'].mean()}\")\n", @@ -597,22 +387,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "x_train_anomalous = training_data[0].copy()\n", "y_train_anomalous = training_data[1].copy()\n", @@ -642,84 +419,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - " 0%| | 0/100 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from scipy.stats import norm\n", "\n", @@ -822,26 +511,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Average value of original data points: 0.00015914351851851853\n", - "Average value of modified, anomalous data points: 0.0\n", - "For reference, these are the average data values of all data points used for training (anomalous):\n", - "data_value 0.0\n", - "data_value_stderr 0.0\n", - "dtype: float64\n", - "These are the average data values of all points (original data):\n", - "data_value 0.000159\n", - "data_value_stderr 0.000000\n", - "dtype: float64\n" - ] - } - ], + "outputs": [], "source": [ "print(\n", " f\"Average value of original data points: {plot_data['original_data_value'].mean()}\"\n", @@ -870,87 +542,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/100 [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
data_valuedata_value_stderr
5-0.0232790.011563
2-0.0177080.011823
7-0.0098150.013890
4-0.0030980.013650
8-0.0012960.012168
\n", - "" - ], - "text/plain": [ - " data_value data_value_stderr\n", - "5 -0.023279 0.011563\n", - "2 -0.017708 0.011823\n", - "7 -0.009815 0.013890\n", - "4 -0.003098 0.013650\n", - "8 -0.001296 0.012168" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "msr_df.head()" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "high_dvl = df.iloc[-30:]\n", "high_dvl.index = high_dvl.index.map(str)\n", @@ -1078,22 +590,9 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "low_dvl = df.iloc[:30]\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -1117,7 +616,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1131,7 +630,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1153,7 +652,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1181,84 +680,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - " 0%| | 0/100 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Compare convergence speed of both methods\n", "import numpy as np\n", @@ -1674,18 +792,9 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Similarity of the ranking of Permutation Sampler and MSR Sampler semivalues:\n", - "SignificanceResult(statistic=-0.1956557569612498, pvalue=0.58801436414807)\n" - ] - } - ], + "outputs": [], "source": [ "from scipy.stats import spearmanr\n", "\n", @@ -1705,1466 +814,21 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "max_checks = [1e3, 2e3, 3e3] if not is_CI else [1, 2]\n", - "num_retries = 3 if not is_CI else 2\n", + "max_checks = [1000, 2000, 3000] if not is_CI else [1]\n", + "num_retries = 3 if not is_CI else 1\n", "num_samplers = 5\n", "twenty_percent = training_data[0].shape[0] // 5" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/20 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Plot results\n", "\n", From bccb3ca58f1f4c7ac5de4a3dddc723faae049584 Mon Sep 17 00:00:00 2001 From: jakob1111996 Date: Mon, 8 Apr 2024 09:55:57 +0200 Subject: [PATCH 29/42] adapt to new parallel backend structure --- src/pydvl/value/semivalues.py | 4 +++- tests/value/test_semivalues.py | 4 ++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 2ab632859..6de2e10ba 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -639,7 +639,8 @@ def compute_msr_banzhaf_semivalues( sampler_t: Type[StochasticSampler] = MSRSampler, batch_size: int = 1, n_jobs: int = 1, - config: ParallelConfig = ParallelConfig(), + parallel_backend: Optional[ParallelBackend] = None, + config: Optional[ParallelConfig] = None, progress: bool = False, seed: Optional[Seed] = None, ) -> ValuationResult: @@ -686,6 +687,7 @@ def compute_msr_banzhaf_semivalues( future_processor=MSRFutureProcessor(u), batch_size=batch_size, n_jobs=n_jobs, + parallel_backend=parallel_backend, config=config, progress=progress, ) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index ed9372674..41ca2a006 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -67,13 +67,13 @@ def test_marginal_batch_size(test_game, sampler, coefficient, batch_size, seed): @pytest.mark.parametrize("num_samples", [5]) def test_msr_banzhaf( - num_samples: int, analytic_banzhaf, parallel_config, n_jobs, seed: Seed + num_samples: int, analytic_banzhaf, parallel_backend, n_jobs, seed: Seed ): u, exact_values = analytic_banzhaf values = compute_msr_banzhaf_semivalues( u=u, done=MaxChecks(200 * num_samples), - config=parallel_config, + parallel_backend=parallel_backend, n_jobs=n_jobs, seed=seed, ) From 637074b18305ed7a6a87ccaf2df2f437287f9e82 Mon Sep 17 00:00:00 2001 From: jakob1111996 Date: Mon, 8 Apr 2024 15:19:47 +0200 Subject: [PATCH 30/42] finish notebook for msr banzhaf --- notebooks/msr_banzhaf_digits.ipynb | 663 ++++++++++++++++++++++++++--- tox.ini | 2 +- 2 files changed, 597 insertions(+), 68 deletions(-) diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb index 87f8647a5..ff653d7c1 100644 --- a/notebooks/msr_banzhaf_digits.ipynb +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "tags": [ "hide" @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "tags": [ "hide" @@ -71,7 +71,7 @@ "plt.ioff() # Prevent jupyter from automatically plotting\n", "plt.rcParams[\"figure.figsize\"] = (20, 6)\n", "plt.rcParams[\"font.size\"] = 12\n", - "plt.rcParams[\"xtick.labelsize\"] = 12\n", + "plt.rcParams[\"xtick.labelsize\"] = 10\n", "plt.rcParams[\"ytick.labelsize\"] = 10\n", "plt.rcParams[\"axes.facecolor\"] = (1, 1, 1, 0)\n", "plt.rcParams[\"figure.facecolor\"] = (1, 1, 1, 0)\n", @@ -92,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -108,12 +108,12 @@ "source": [ "## Loading and grouping the dataset\n", "\n", - "pyDVL provides a support function for this notebook, `load_digits_dataset()`, which downloads the data and prepares it for usage. The data consists of greyscale images of shape 8x8 pixels with 16 shades of grey. These images contain handwritten digits from 0 to 9." + "pyDVL provides a support function for this notebook, `load_digits_dataset()`, which downloads the data and prepares it for usage. The data consists of grayscale images of shape 8x8 pixels with 16 shades of gray. These images contain handwritten digits from 0 to 9." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "editable": true, "slideshow": { @@ -130,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "editable": true, "slideshow": { @@ -156,15 +156,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Visualize some of the data\n", "fig, axes = plt.subplots(2, 2, figsize=(4, 4))\n", "for i in range(4):\n", " ax = axes[i % 2, i // 2]\n", - " ax.imshow(np.reshape(training_data[0][i], (8, 8)), cmap=\"grey\")\n", + " ax.imshow(np.reshape(training_data[0][i], (8, 8)), cmap=\"gray\")\n", " ax.set_xlabel(f\"Label: {training_data[1][i]}\")\n", "plt.suptitle(\"Example images from the dataset\")\n", "plt.tight_layout()\n", @@ -180,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -204,9 +217,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Accuracy: 0.665\n", + "Test Accuracy: 0.619\n" + ] + } + ], "source": [ "import torch\n", "from torch import nn, optim\n", @@ -280,9 +302,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
data_valuedata_value_stderr
66-1.0485240.029862
152-0.9945730.008960
64-0.7608250.018543
3-0.7181650.642347
14-0.7075690.323538
\n", + "" + ], + "text/plain": [ + " data_value data_value_stderr\n", + "66 -1.048524 0.029862\n", + "152 -0.994573 0.008960\n", + "64 -0.760825 0.018543\n", + "3 -0.718165 0.642347\n", + "14 -0.707569 0.323538" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "df.head()" ] @@ -322,7 +424,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "editable": true, "slideshow": { @@ -333,7 +435,20 @@ "invertible-output" ] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "low_dvl = df.iloc[:30].copy()\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -360,7 +475,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "editable": true, "slideshow": { @@ -371,7 +486,27 @@ "invertible-output" ] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average value of first 10 data points: 0.6300257540520159\n", + "Exact values:\n", + "39 0.392304\n", + "167 0.461181\n", + "33 0.468827\n", + "169 0.519828\n", + "135 0.551593\n", + "19 0.594768\n", + "51 0.636773\n", + "140 0.741426\n", + "71 0.880786\n", + "121 1.052771\n", + "Name: data_value, dtype: float64\n" + ] + } + ], "source": [ "high_dvl = df.iloc[-10:].copy()\n", "print(f\"Average value of first 10 data points: {high_dvl['data_value'].mean()}\")\n", @@ -387,9 +522,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3MAAAHqCAYAAACuvxfYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABSqElEQVR4nO3de7wcdX3/8dcHEoJASFQUQUAUvBdBUasWC1T9iVVLUOSmSChSBWuJtFWxWkJbxVtpRPGugIqKV1DEG0pQvCFKEBRFkCAXQUEIhEvC5fv74zsHls2enLM7s2fnu7yej8c+Ts7sznc+O+e9k/3szM5ESglJkiRJUlnWGXUBkiRJkqT+2cxJkiRJUoFs5iRJkiSpQDZzkiRJklQgmzlJkiRJKpDNnCRJkiQVyGZOkiRJkgpkMydJkiRJBbKZkyRJkqQC2cxJ9zMRkSJiaQPjLI2I1EBJ/S536+o5nDDTyx5URCyPiOWjrqNTUzm4P2nj33GYImLjiDi2et53VpnZYYp57lfrSJJGzWZOaqmIeGpEHB8Rv4+I2yLipoi4ICLeHREPH3V9ksbeu4DXARcARwNHAdeMtKL7gYiYExH/GhE/q7b7t0TExRFxYkQ8pI9x5kfEv0fESRHx646G/LlTzLduRLw+In5Z/d/zl4g4PSKeVf/ZSWrarFEXIOm+IiKAdwBvAO4EvgN8AVgPeBbwb8ChEXFASumLAyzi8cCtDZT6SmCDBsbRaDSVg/uT54y6gBn2IuDilNKL+5jn/raOGhURDwO+DWwH/BD4KHAXsBXwfODdwJ+nOdzW5IYc4ErgOmDTKZYfwOeAPYHfAu8HHgTsDXw/Il6aUjp1+s9I0rDZzEnt81ZyI7cceFFK6Vedd0bES4FPA5+LiOellM7sZ/CU0m+aKDKl9IcmxtFoNJWD+5OU0qWjrmGGbQ58v58Z7ofrqDERsQ7weeCxwD+klL7WdX/Q3xFVlwPPBc5LKf2lOjT9gCnm2YfcyP0IeE5K6fZq2R8CzgY+GhHfSynd3EcdkobIwyylFomIrcnN3B3k/8x/1f2YlNKXgNcD6wIfrN4ATMy/sDqMZmFE7FZ9r21F53fbJvuuVERsVh3W+afq0JplEXFAROxSzbO46/FrfGeu87ERsUNEfD0iboyIWyPirF6H6UTE5hHxnxHxw4i4JiJWR8TVEfGZiHhCn6twDRGxXkT8c3WY0OURsao6bOiMiHjBJPMsr24bVoe1/qGa75KIeGP1pqp7nqiW86uIuD0iroqI90fEvAFqTtX63SQiPhIRf6yW/6uIOHCSedaJiNdUh2atrA7N+llEHNKZke5ldE2bGxFvjYgLq8O7bo6ISyPi5IjYsXrM46p5J/0QIfLhwHdExGZrecz6VTb+FBE9P1iMiA9Wy3pR1/THRcQJEXFFlZdrq7w8tscYJ1RjPCoiXhf3Hjq2tLo/qpz/KCL+XP3troiIb0XE3l1j9fw+WOTD4t5UPe9bq3X3g4jYq8dj7/nOZ/Xvz0XEddVyz+1+rtU860XEv0TELyLihmoZyyPi1JjikLmucTaLiOOqeVdXz/fLE3/bjsdNvLYD2Lmqd1rfsey1juK+26XnVetmZbX84yNifvW4J0fEadVzXBkRX428Texexo4R8d6IOD/ya/n2iPhdRPxvRDxwkrrmRcSSiLiyevxvIuLwKhc9v4MbERtExBGRt4W3VDX9OCL27fHYaedoLRYAzwb+r7uRA0jZXdMci5TSDSml76aU/jLdeYBDqp9vmWjkqrF+BpwMPITc7ElqCffMSe1yIPl1+fmU0gVredzHgP8kf4K7M9D9xnpPYDfgG8CHgEesbaER8VDgx9Xjvk/+VPZhwAfIh/z066nkvYs/rmrdCngp8N2I2CGl9NuOx/4t8KbqOXwJWAk8unoO/xARf5NSOn+AGiY8CHgv+Tl9h3yI0mbAi4HTI+LglNLHesw3G/gWee/EN8iHvC4gHwK7Pvn7Q52WAP8C/BH4CLkh3x34a/Ihsqv7rHs++TCr1cAXgTnAy4BPRMTdKaUTux7/KWA/4AryOk/AHuS/4U7Ay9e2sIgI4JvkQ3kn/m53AlsAuwI/AH6eUvpN5EZu14h4TErp4q5xngX8FfCllNIfJ1teSun2iDgZ+CfgBUD3Xog55EO7rq3qmpi+G/Bl8t/na8AlVY0vAV4YEbumlH7RY5HvJb9R/jpwOvnQNYC3AUcAl5H3iqwg5+Np5PV98mTPoapnPXJOdgZ+AxxHPvx4T+DkKu9v7jHrI4BzgN+T/3YTh7KdGhHP7drjfgKwL3Ah8EngNnIudyK/zs9YW41VnY8k71nZHPge8Flgy+o5vjDy4XOndSxvKXAkee/OCdX05VMtZwr/QD508zTydulZwEJg64g4AvguOWcfJx9m+GLgURHxpJTS3R3jHEzO9lnk574OsCNwOPCCiPjrzj1HEbF+9ZyfApwHnATMA/6DnIk1VA3m94AnA78APlEt5/nAZyLiiSmlt3TMUitHlf2qn5+NiE2rdfVQ8vcUv51SumoaYwysWk/PIh9+/YMeD/kGsD/wd8Dxw6xFUh9SSt68eWvJjfxmJgEHT+OxJ1WPfUvHtIXVtLuB3SaZLwFLu6Z9vJr+zq7p2wOrqvsWd923NG9C7jNtl+qxCVjYdd+rq+kf6Jr+UGBujzq3Jzd23+iavnU1zgnTXKdzgC16TJ9HfnP8F+ABXfctr5Zxeud9Va03VrfZHdOfVT3+EuBBHdPXJzdGCVjeRw4m1uHHgHU7pj+B3GD9uuvx+1aP/wWwUcf0DYFzq/v2W1sOyG+eE/CVHvWsAzyw4/c9q8e+p8djT6jue940nuczq8d+scd9L6vu+9+OaQ8EbiB/9+cJXY//qyovv5iknquAR/ZYzvXk7xNt0OO+TXrkYnnXtCM6sjKrKysTOXpWj/wm4MiusZ4/MVZXTu+u/o7r9qjxwdPM1Leqsf+ja/qzqkxd35mdXhmZ5nJ6raOF1Vh3Ajt35eo71X1/AV7eNd/Edmn3rumPmGRdHFQ9/o1d099aTf8sEB3TtyR/uLPG9qQjN2/omr4++cOFu4EdBsnRWtbd5dUyDwZu6chJIn+o85bpjLOW8See03Mnuf+J1f0XTHL/U6v7f1qnDm/evDV78zBLqV0mDku7YhqPnXjM5j3uOzWl9M0e09dQ7VnYl/xJ8v903pfyHrFPTmecLj9MKZ3QNe0T5DdzT+9axp9Sj+9fVMv+HnkP0OwBapgYZ1VK6coe01dUNT2Q/Ol5L/+SUrqts1bgVPIb7M5D+iYOfXxb6jikKeXDlI4YsPRbgcNTx2FVKaVfk/fWPT4iNup47D9WP9+UUlrZ8fhbgDdWv75qmsu9rXtCSunulNINHZNOIe+BXFjtQQPu2ZuxF3Ap09hblFL6MXAx8OKIeFDX3QdUPzv3QL6SvMfyyGpddI51IflkEU+O3ofnviuldNkkpdzBvXvqOse8bqrnQF73ify3urNj3j8B/1392mvdX86ar7dvAX/gvq+RRD7ccRW5geiu8fqpCoyILYD/V439rs77Uko/Ijc5DyLv3Rymz6aUzupY9t3kvZIAF6aUTup6/MS2Z4fOiSmly1Pvww0/AdxEboo7HUBed0eklFLHOFeQ96jfR0Q8GHgFcG5KqXt93U5+TQX37kmbUCdHkD8AAPggufF6FDnvLyV/iPHfEbFwmmMNYl71c8Uk909Mnz/EGiT1ycMspfF0Th+PfSzwAPIbl15faj+b6TcCE87tnpBSuiMiriU3T/cRES8EXkP+5HcT1tw2bUJuHgYSEU8E/p18SOdm5E/XO/W61MOKlNIlPaZPNNGdz+Mp1c+zWNPZ9HiDNw2/SyndNMXyJxq3p5DfrC7t8fizquU/eYrl/RpYBuwbEY8gN61nk3Nxn0NEU0p3RsRHyYf6vhT4THXX/uQsfaTzTfMUTiQforYP+ZBQqkPMnk8+ccMvOx77zOrn9tH1Hc7KY6qfj6+eT6fJXhMnkU+//+uI+Dx5ff24avbXKiLmAtsCV6XeJ5T5XvWz17pfNklDcgX3Pk9SSjdFxNfIhxwui4gvkQ+B+2lKabpnI51Y/g9SSndMUucrqscN8uHNdK2xXQCurn7+vMd9E4cVbtE5sfpw59XkzDyB3IR0fjj98I7HbgxsA1yRUlreYxln95j2NPJ3ktf4rnBl4sOlx3dMGzhHHSaewxkppdd2TP9yRNwBfJX84dAJABGxgK5Gl5yrU/pYpqTC2cxJ7XIN+Q3CltN47MRjru5xXz/Xgpr4NPbaSe6fbPra3DjJ9DvJb5LuERGHkT8dv4F8yNUfyHulEvk7atuTD5UcSEQ8g/xmdRb5MNavkj+9v5v8Rmj3ScZf23OA+z6PSddh1fhM95P5Osv/S3fT1bX8h3bf1/W4uyLi78gN2p7AO6u7bo6IE8l7NVZ2zPIR8neOXs29zdw/kQ8HO35ty+rySfIerAOomjny9/tmcd+9cgAPrn4ePMWYG/WYNtlr4vXk760dSP7u5puAOyPidOBfJ2noJ0z83Sf7oGFi+vwe9904yTx3subJyfYm7w3aj3u/q3l7RHwR+LeU0lSv0Tp1NqlXY3PnNO7r3jN/Mvk7c78nf+hwDXnPJcAi7vt63rj62c/2bSJnT2PyvfZw35zVydGEG8mv06/0uO908mvrMRExr2oSF7Dm2SlPJO85H8TE32DeJPdPTL9xwPElDYHNnNQuZ5NPNvFc8iFjPUXEuuTvp0E+7K7bdPeKQG5sYPLrD631ukR1RD6L4WLym7GnpK4TZkTEM3vN16e3kPcW7ZpSWto1/hHkZq6uiTdBm5Lf0HUuYxZ5z+Iah3o2aAXwoIiY3b3npWP5vfby3Ud1KOXrgddHxLbkk3q8Gvhn8hv9/Tsee1VEfBXYIyIeRz5M76+Ak1NK070OFimlKyPie8BzI+Jx1R6uA8iHrH2m6+ET63n7rj1201rUJMu/i/xhwpLqREA7kff4vAx4YnWii1W95u2o52GT3L9Z1+MGUh3quxhYHBFbkvcwLyTvTduaSU7iMdN1zoSIeCq5kTsDeEHnoa2Rz9r6hq5ZBtm+TayH/0spHT6dumrmaMJvufd7uWuMHxE3kV/LDyAfObCQnIOmXErei/+oiJjVuW4rj65+Xoyk1vA7c1K7nED+z3SP6tDAyfwj+btyv6X3oX39+A35e1JPqg4b67ZTzfHXZhNyk/CjHo3cRtx7+GId25L3Wi3tcd/ODYwP+cQjk423E117I4fgPPL2/G973Pe31fJ7neFxUimlS1JKHyc/p5X0bnon9qS9mrxXDuDD/SynckL184CI2AF4EvnEN91N4U+qn1M1LwOpvr/55ZTSXuS9uduQG9TJHn8z+Q3wwyPi0T0esmv1s691P0WNV1TfLXs++YQ7O1Xf8Vqb86qfO0Xvy0A0XucQbVv9/GqPZuPp5EbnHtWhyr8n/4227jFer+3bOeQ99wPlrN8cdZj4nukaj60OPd6E/FocZE//lKrvA/6IfDbWXs994lIu3+txn6QRsZmTWiSl9Hvg7eTDir7a60QO1fck3ktu+g5J9z1l9yDLXE0+bGkeeS9W57K2J590Ylj+RD6kcsfOE3pU34l5L/nNS13LyXutntQ5MSIOYs0TJQzqhOrnf3SeyKM61ffRDS1jbT5R/Tw6IjboWP4G5EspQD4z4KQi4pER8agedz2QfNjaGidGIR+2ejF5T9pewG9Tnxexr3yZvAflFdy7p+GEHo87nrzX4siIeHr3nZGvtbfLdBca+fpwf9Nj+mzynkbI+VybT5BPhvHuao/5xBibkM+iOPGYgUTEQyJiux53bUg+zO9OprjsRXUCoO+Q9+It6hr/r8mHb95A78P72mZ59XOXzonV3rDjJpnnk+T3O0dXl+CYmGdLutYH3HPympOAp0a+7uIaH8ZExDbV5R6ayhHknNwKvLbztVgt/93Vr1/o0cQ26YPVz/+ptl8TNTyNfLjvn8mXkJHUEh5mKbXPYvIbtcOB8yPiW8CvyA3es8jXLbsN2HfAN869vIl87aA3VG/ufkQ+9Gov8nc1FtDjTHp1pZTujohjq+VfEBGnkq/Jtiv5TdCZ3LvXYFBLyE3b2dWJCVaQT7SyE/n6bbUvgJtS+mFEvI98AoQLq+8yTVxn7gZqnLxlmsv/TETsTv57/SoiTuHe7xw+knzoY/eZArttTz7Rws+Ai8jfxXwI+TnM5t7v0HUuN0XEh4BjqkkfGbD+2yLiC+RTyx9KPs3713s87vqI2JPcdPwkIr5Lfm0k8ndIn0n+vlP3CW4m8wByLi4hn4Dj8mre55G/u/rVlNJFU4zxHvIei93Jr9fTyXs2XkY+ZO5dKaVeJ9mYrocD50XEBcAvySdI2Zh8DbKHAcdOcuKibq8hH5L97oj4f+STkUxcZ+5u4MBpjjNqPyM/j5dExI/Ih6ZvSv4b/Jbe3yF+F/m1sA/w2Ij4NvnDq73I19VcwJrbt38mH1b4X8D+EXE2+ft1m5Oz8TTyWYAvo5kcTRxyfCj5Q4tlEfEV8iUbdiF/v/di1jyMdK0i4j3c+6HYxF7If4+IV1T/PqXrhCmfI5/VdE9y7r5Gfk3tTd7Df/AkJ2aSNCqpBddH8ObN25o38iFDJ5LfLNxGPrzmQvKbxzWum1bNs5Ae13jrekzPa0eR3zSeSP7k9TbymQ0P4N5rii3qevxSJr/O3OJJlr2cNa9BNYvcuP66Wu415NOVP4J7r4u0dcfjt6aP68xV87yIfIjezeQ9O9/m3u8drbG+etXZcd/iap5duqYH+Q3gReSTMVxN3lMwb23j9fM3qu5bY51U09chN0Lnkj/dv5X8xvK1wDpTLYN8xsC3k98oT5xQ4kryhYJfsJZaH0jeS3wb07zm2STj7MS919R63xSP3Rp4P/A74HbyXr3fVLlZMJ31Vd03m/zm+BvkE+/cTs7/T8jNz3rTyQX5jfubya/P26qcnU3+wKVX7ZPml67XFfkw5P8kH9p2VfV3+WP1uH3puG7aNNbxw8l7Xi4n7827jnyyjKf1m8O1LGONdcRatkusZZsx2boif9DzgWpZt5MPdX07uYme7G80HziW/LpcVeXlX8nb2QQs6THPeuTX9I/IHwKtqnLyXfIevQcPkqNprMNdyNeyu6H6O11CbkjnD/C6Ws59r1fXfeu13meRvzt7QZXnG8gf6j2r3+V78+Zt+LdIqZ/zJEi6v4mIt5HfqO6W8nWwpHtUhzWeCXw6pbT/2h8ttUtEHEzeo/yalNIg3/eUpJGymZMEQERsnlK6umvaduRPpVcDD0/5C/LSParDCl8APCOl9NNR1yP1Msn2bSvyHtTNgEd03y9JJfA7c5ImnFt95+NC4Bby90VeSD5879U2cppQNfkvAnYkN3Kn2cip5b5UnZDk5+RDrbcmZ3gD8jUUbeQkFck9c5IAiIgjyScC2BqYS37D8xPgPan3af11PxURC8knabgJ+BZwaEppKKdLl5pQnVhkf/KHVPPI30E+D3h/SunLo6xNkuqwmZMkSZKkAnmdOUmSJEkqkM2cJEmSJBXIZk6SJEmSCmQzJ0mSJEkFspmTJEmSpALZzEmSJElSgWzmJEmSJKlANnOSJEmSVCCbOUmSJEkqkM2cJEmSJBXIZk6SJEmSCmQzJ0mSJEkFspmTJEmSpALZzEmSJElSgWzmJEmSJKlANnOSJEmSVCCbOUmSJEkqkM2cJEmSJBXIZk6SJEmSCmQzJ0mSJEkFspmTJEmSpALZzEmSJElSgWzmJEmSJKlANnOSJEmSVCCbOUmSJEkqkM2cJEmSJBXIZk6SJEmSCmQzJ0mSJEkFspmTJEmSpALZzEmSJElSgWzmJEmSJKlANnOSJEmSVCCbOUmSJEkqkM2cJEmSJBXIZk6SJEmSCmQzJ0mSJEkFspmTJEmSpALZzEmSJElSgWzmJEmSJKlANnOSJEmSVCCbOUmSJEkqkM2cJEmSJBXIZk6SJEmSCmQzJ0mSJEkFspmTJEmSpALZzEmSJElSgWzmJEmSJKlANnOSJEmSVCCbOUmSJEkqkM2cJEmSJBXIZk6SJEmSCmQzJ0mSJEkFspmTJEmSpALNmukFRkQAmwM3z/SyVaS5wNUppTTqQsD8aiCtybD51QBak18wwxpIazJsfjWAKfM7480cOcRXjmC5KtcWwFWjLqJifjWItmTY/GoQbckvmGENpi0ZNr8axFrzO4pmrlWfRrzpTW+qPcazn/3sBippxn777dfIOCtWrGhknIa0KTNtqoXtttuu9hhf//rXG6ikmVpalrsmtSU3jdRxyCGHNDEML3rRi2qPsdVWWzVQSTPjHH300Q1UAu94xzsaGadBbckvNFTLvHnzmhiGI444ovYYTf2//Yc//KH2GE28JwI4++yzGxmnQW3JcFvqAGCnnXZqxRjQzGtp3333baASOP300xsZp0Frzc0omrlWWX/99WuPseGGGzZQSTPyHnzdX6y77rq1x9h4440bqMTs3Z/MmTOnkXGa2HbOnTu3gUqaeR008f+JZkZT26sm/uZNbYM32mij2mPMmnW/f1t4v9LE37up7V4Tr4PZs2c3UEl5PAGKJEmSJBVooGYuIl4bEcsj4vaI+GlEPL3pwqRhMb8qnRlWycyvSmeG1SZ9N3MRsTdwDHAU8BTgfOBbEfHQhmuTGmd+VTozrJKZX5XODKttBtkzdzjw0ZTS8SmlXwOvAW4F/rHRyqThML8qnRlWycyvSmeG1Sp9NXMRsR6wI3DGxLSU0t3V789stjSpWeZXpTPDKpn5VenMsNqo39PYbAKsC1zbNf1a4HG9ZoiIOUDnqc+aOfWY1D/zq9L1lWHzq5ZxG6zSuQ1W68zE2SyPAFZ03LxYokpiflUy86vSmWGVzPxq6Ppt5q4D7gI27Zq+KXDNJPMcDczruG3R5zKlpphfla7fDJtftYnbYJXObbBap69mLqW0Gvg58JyJaRGxTvX7jyeZZ1VK6aaJG1NcxVwaFvOr0vWbYfOrNnEbrNK5DVYbDXLp92OAEyPiXOAcYBGwIXB8g3VJw2J+VTozrJKZX5XODKtV+m7mUkonR8RDgP8CHgYsA3ZLKXV/GVRqHfOr0plhlcz8qnRmWG0zyJ45UkrvB97fcC3SjDC/Kp0ZVsnMr0pnhtUmM3E2S0mSJElSw2zmJEmSJKlAAx1m2QY77LBDI+MceeSRjYzThMsvv7z2GIsXL65fCLBo0aJGxtFwLVmypBVjANx4442NjKP2mz9/fiPj7LzzzrXHaGK7CbBixYraYzT1/5KGr6n/45r4my9YsKD2GAC77LJLK8YAWLp0aSPjaLiayN5hhx1WvxDgqKOOqj3GgQce2EAlcOqppzYyzkxxz5wkSZIkFchmTpIkSZIKZDMnSZIkSQWymZMkSZKkAtnMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKZDMnSZIkSQWymZMkSZKkAtnMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFWjWqAsY1A477NDIOCtWrKg9xgknnFC/kIbGWbJkSe0xALbeeuvaYyxfvrz2GOOqqfzOnz+/9hiLFy+uPYbuX5ra5jXxOli0aFHtMQAuu+yy2mOccsop9QvRjGhi2wlw44031h5j6dKltccAmDdvXu0xmspwE+MsW7as9hhauzPPPLP2GE29lpp4L9JUZkp7D+yeOUmSJEkqkM2cJEmSJBXIZk6SJEmSCtRXMxcRR0TEzyLi5oj4U0ScEhGPHVZxUtPMsEpmflUy86vSmWG1Ub975nYGjgOeATwPmA18OyI2bLowaUjMsEpmflUy86vSmWG1Tl9ns0wp7db5e0QsBP4E7Ah8v7mypOEwwyqZ+VXJzK9KZ4bVRnW/MzdxHty/1C1EGhEzrJKZX5XM/Kp0ZlgjN/B15iJiHWAJ8MOU0oVredwcYE7HpLmDLlNq0nQybH7VVuZXJfM9hErnNlhtUWfP3HHAXwH7TPG4I4AVHbcrayxTatJ0Mmx+1VbmVyXzPYRK5zZYrTBQMxcR7wdeBOyaUpoqmEeTd0NP3LYYZJlSk/rIsPlV65hflcz3ECqd22C1SV+HWUZEAO8D9gB2SSldNtU8KaVVwKqOMfqtUWpMvxk2v2oT86uS+R5CpXMbrDbq9ztzxwH7AbsDN0fEw6rpK1JKtzVamTQcZlglM78qmflV6cywWqffwywPIe8mXgr8seO2d7NlSUNjhlUy86uSmV+Vzgyrdfq9zpz7h1U0M6ySmV+VzPyqdGZYbVT3OnOSJEmSpBGwmZMkSZKkAg180fBRmz9/fiPjnHDCCbXHWLRoUe0xmrJs2bJGxlmwYEHtMZYsWVJ7jHHVVH5vvPHGRsaR+rF8+fJGxhm37czWW2/dyDi777577TFOPfXUBioZX6ecckoj4zSRv8WLF9ceA+DII49sZJwm7LDDDrXHaOr9jCbXxHbiqKOOaqAS2GWXXWqP0dQ2uDTumZMkSZKkAtnMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKZDMnSZIkSQWymZMkSZKkAtnMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKZDMnSZIkSQWymZMkSZKkAs0adQGjduONN466hEYtX768kXHmz5/fyDjqbd68eY2M08Tf+5RTTqk9BsDuu+9ee4zLL7+8gUpghx12qD3GuG0bmrR48eJGxlmwYEHtMbbffvv6hTRkl112aWSc8847r5FxNLmlS5c2Ms6iRYtqj9FUbh75yEfWHmPJkiX1C6GZbbDK0NRr6cwzz6w9xlFHHdVAJc29l54p7pmTJEmSpALZzEmSJElSgWzmJEmSJKlAtZq5iHhTRKSIWNJQPdKMMb8qnRlWycyvSmZ+1RYDN3MR8TTg1cAvmytHmhnmV6UzwyqZ+VXJzK/aZKBmLiI2Ak4CDgZuaLQiacjMr0pnhlUy86uSmV+1zaB75o4Dvp5SOqPJYqQZYn5VOjOskplflcz8qlX6vs5cROwDPAV42jQfPweY0zFpbr/LlJpiflW6fjJsftU2boNVMvOrNuprz1xEbAm8F3h5Sun2ac52BLCi43ZlXxVKDTG/Kt0AGTa/ag23wSqZ+VVb9XuY5Y7AQ4FfRMSdEXEnsDPwL9Xv6/aY52hgXsdtizoFSzWYX5Wu3wybX7WJ22CVzPyqlfo9zPK7wHZd044HfgO8M6V0V/cMKaVVwKqJ3yOi3xqlpphfla6vDJtftYzbYJXM/KqV+mrmUko3Axd2TouIW4DrU0oX9p5Lagfzq9KZYZXM/Kpk5ldtVeui4ZIkSZKk0ej7bJbdUkq7NFCHNBLmV6UzwyqZ+VXJzK/awD1zkiRJklQgmzlJkiRJKlDtwyxH5bLLLmtknD322KORccbN/PnzR13CWDv//PMbGeeUU06pPcaJJ55YvxBg1113rT3GDjvsUL8QYMmSJbXHWLhwYe0xxtWNN97YyDjbb7997THOOuusBiqBRYsW1R5j2bJltcdQWZYuXdqKMZrS1Gu7qXE0XIsXL649RlP/V15++eW1xzjvvPMaqKQ87pmTJEmSpALZzEmSJElSgWzmJEmSJKlANnOSJEmSVCCbOUmSJEkqkM2cJEmSJBXIZk6SJEmSCmQzJ0mSJEkFspmTJEmSpALZzEmSJElSgWzmJEmSJKlANnOSJEmSVCCbOUmSJEkqkM2cJEmSJBXIZk6SJEmSCmQzJ0mSJEkFspmTJEmSpALNGnUBgzr11FMbGee9731v7TGWLVtWv5CGxjnggAPqFwIceOCBjYyj3pYvX97IOCtWrKg9RlO1NDHO4sWLa48BsHTp0kbGUW9NbfOa0FRm2vScVI5FixbVHmPJkiW1xwDYYYcdao+xyy671B4DmntdariOPPLI2mMsWLCgfiE08368ifdEJXLPnCRJkiQVyGZOkiRJkgpkMydJkiRJBeq7mYuIh0fEpyPi+oi4LSIuiIinDqM4qWnmV6UzwyqZ+VXpzLDapq8ToETEA4EfAmcCLwD+DDwauKH50qRmmV+VzgyrZOZXpTPDaqN+z2b5RuCKlFLnqQ4va7AeaZjMr0pnhlUy86vSmWG1Tr+HWf4DcG5EfCEi/hQR50XEwcMoTBoC86vSmWGVzPyqdGZYrdNvM/co4BDgd8DzgQ8Cx0bEpBc3i4g5EbHxxA2YO3C1Uj3mV6XrK8PmVy3jNlilcxus1un3MMt1gHNTSm+ufj8vIv4KeA1w4iTzHAHUvyqhVJ/5Ven6zbD5VZu4DVbp3AardfrdM/dH4Ndd0y4CtlrLPEcD8zpuW/S5TKkp5lel6zfD5ldt4jZYpXMbrNbpd8/cD4HHdk17DHD5ZDOklFYBqyZ+j4g+Fyk1xvyqdH1l2PyqZdwGq3Rug9U6/e6Z+z/gGRHx5ojYNiL2A/4JOK750qTGmV+VzgyrZOZXpTPDap2+mrmU0s+APYB9gQuBtwKLUkonDaE2qVHmV6UzwyqZ+VXpzLDaqN/DLEkpnQacNoRapKEzvyqdGVbJzK9KZ4bVNv0eZilJkiRJagGbOUmSJEkqUN+HWY6bww47rPYYRx11VAOVwPz582uPseuuu9YvBFi6dGkj42i4dtlll9pjLFmypPYYAEceWf9SOk29lhYvXtzIOOptwYIFjYxz1lln1R7DbZVKl1JqZJzLL5/0pKDTdsIJJ9QvpMFxNFwHHnhg7TFOOeWU+oXQzP8Hy5Ytq19IgdwzJ0mSJEkFspmTJEmSpALZzEmSJElSgWzmJEmSJKlANnOSJEmSVCCbOUmSJEkqkM2cJEmSJBXIZk6SJEmSCmQzJ0mSJEkFspmTJEmSpALZzEmSJElSgWzmJEmSJKlANnOSJEmSVCCbOUmSJEkqkM2cJEmSJBXIZk6SJEmSCjRr1AWM2h133FF7jJUrVzZQCdx66621x7jzzjsbqESluOuuu2qPccsttzRQCdx00021x7j99tsbqETD1tTfqansSaOyatWq2mM0se0EuPnmm2uP4Tb4/mX16tW1x2gqv038f5BSaqCS8sRMP/GIeDhw5YwuVKXbIqV01aiLAPOrgbUiw+ZXA2pFfsEMa2CtyLD51YDWmt9RNHMBbA5M9hHSXHLQt1jLYzS40tbvXODq1JKPW6aRXyhvHZekxHXbmgyb31Yobf22Jr9ghlugxHXbmgyb35Ercd1Omd8ZP8yyKmby7jJi4p83p5Sa2XerexS4fltV41T5hSLXcTEKXbetqdP8jl6B67dVNZrh0Sp03bamTvM7WoWu2ynr9AQokiRJklQgmzlJkiRJKlAbm7lVwFHVTzXP9Tt8ruPhcd0On+t4uFy/w+c6Hh7X7fC5jodnLNftjJ8ARZIkSZJUXxv3zEmSJEmSpmAzJ0mSJEkFspmTJEmSpALZzEmSJElSgVrXzEXEayNieUTcHhE/jYinj7qm0kXE4ohIXbffjLqucWR+h8MMzxwz3DzzO3PM73CY4Zlhfodj3PPbqmYuIvYGjiGfNvQpwPnAtyLioSMtbDz8Ctis47bTaMsZP+Z36MzwkJnhoTK/Q2Z+h84MD5H5HbqxzW+rmjngcOCjKaXjU0q/Bl4D3Ar842jLGgt3ppSu6bhdN+qCxpD5HS4zPHxmeHjM7/CZ3+Eyw8NlfodrbPPbmmYuItYDdgTOmJiWUrq7+v2Zo6prjDw6Iq6OiN9HxEkRsdWoCxon5ndGmOEhMsNDZ36HyPzOCDM8JOZ3RoxtflvTzAGbAOsC13ZNvxZ42MyXM1Z+CiwEdgMOAR4J/CAi5o6yqDFjfofLDA+fGR4e8zt85ne4zPBwmd/hGuv8zhp1ARq+lNI3On79ZUT8FLgc2Av4+GiqkqbPDKtk5lelM8Mq2bjnt0175q4D7gI27Zq+KXDNzJczvlJKNwIXA9uOuJRxYn5nkBkeCjM8Q8zvUJjfGWSGG2d+Z9C45bc1zVxKaTXwc+A5E9MiYp3q9x+Pqq5xFBEbAdsAfxx1LePC/M4sM9w8MzxzzG/zzO/MMsPNMr8za9zy27bDLI8BToyIc4FzgEXAhsDxoyyqdBHxHuBr5F3Km5NPe3sX8NlR1jWGzO+QmOEZY4aHwPzOGPM7JGZ4RpjfIRn3/LaqmUspnRwRDwH+i/yFz2XAbiml7i+Eqj9bkAP7YODPwNnAM1JKfx5pVWPG/A6VGZ4BZnhozO8MML9DZYaHzPwO1VjnN1JKo65BkiRJktSn1nxnTpIkSZI0fTZzkiRJklQgmzlJkiRJKpDNnCRJkiQVyGZOkiRJkgpkMydJkiRJBbKZkyRJkqQC2cz1KSIWR8RAF+eLiIURkSJi64bL6lzG1tUyFg5rGSqbGVbJzK9KZ4ZVMvPbPvebZi4inhgRn46IqyJiVURcHREnRcQTR11b20TE/Ij4SET8OSJuiYgzI+Ipo67r/s4M9ycinhsR34uIFRFxc0T8PCL2HnVd91fmd3oiYmn1RqTX7Y5R13d/ZoanLyKeFxFnR8StEXFDRHxxmG/gNTXzO30RsWNEnBYR10TEyoj4ZUT8S0SsO+raeomUBmquixIRLwE+C/wF+DhwGbA1cBDwYGCflNJXpjnWLGBWSun2AepYF5gNrEpDWvHVxvIy4MCU0gkDzL8O8ANge+DdwHXAocCWwI4ppd81VqymzQz3PcaB5PX0HeCrwF3AY4GrUkrvaaZSTZf57Wv+5wGbdk3eEPgQcHpK6YV1a1T/zHBf878IOBX4BfApYGPgMGAV8OSU0p8bK1bTYn77mn9H4EfA78jr6lbgBcDuwLEppcMaK7YpKaWxvgHbALcAFwEP6bpvk2r6SuBRU4yz4aifyzSf79ZAAhYOOP9e1fx7dkx7CHAD8JlRP7/7480MDzT/rcB7R/1cvJnfhsZ8RTXmfqN+fvfHmxnue/5fkd8Ir9cxbXvyh2r/O+rnd3+7md++5/8I+YOHB3VNPwtYMern1+t2fzjM8t+BDYB/Sl2fBqWUrgNeTf7U8w0T0yeOB46IJ0TEZyLiBuDszvs6x4mIB0TEsRFxXXU411cj4uHVGIs7HrfGscIRsbzalbtTRJwTEbdHxO8j4pVdy3hQRLwnIi6odvneFBHfiIjtp1oBETE7Ih4XEZtNY33tCVwLfLljPf0Z+Dywe0TMmcYYapYZ7i/DrwHWBf6zmnejiIhpzKfhML/95beX/chvxk4dcH7VY4anmeGIeBDwBOArKaXVHevpfHLTsM9Uy1LjzG9/2+CNgduBG7um/xG4bRrzz7j7QzP3YmB5SukHve5MKX0fWA70OnTlC+QXwJuBj65lGScArwNOB95I/mN/vY8atwW+SD4k7F/Je8FOiPsex/woYAFwGnA4+RDI7YCzImLzKcZ/OHkjevQ0anky8IuU0t1d088hr4vHTGMMNcsM95fh5wK/Af4+Iq4Ebgauj4j/jnwYsWaW+e0vv/cREQ8BngecklK6pd/51QgzPP0MT3zg2+tN763A5hHxsCnGULPMb3/b4KXkhu7DEfH4iHhERLwGeMk0559xs0ZdwDBFxDxgc6b+NPOXwD9ExNyU0s0d089PKe03xTKeQj40cUlK6fXV5A9ExPHkwwqm47HA30680CLi88AVwIHAv1WPuQB4TGeTFRGfIr9pPQj472kuayqbAd/vMf2P1c/Nq1o0A8zwQB5NPpzneOBdwPnkjfBbyNu8IxpajqZgfhuxNzm3Jw1pfK2FGe7bteQ9Gn/TOTEiHkzeYwf5jfU1DSxLUzC/A/ko8ETyHstXVdPuAv45pfShhpbRqHH/lHpu9fPmtT7q3vs37po+nT/abtXPD3RNf9805p3w685PTKrd4L8lfwoxMW3VRIAjYt1qw7iyetxazzSZUlqeUoqU0sJp1PIA8rHC3W7vuF8zxwzTd4Y3Ah4IHJlS+s+U0pdSSi8HvgkcFhFz1z67GmR+6Tu/3fYD/kz+xFozzwwz/QxX438YeE5EHB0Rj458QonPA+tVD/N9xMwxv/S3DU4p3QVcCnwLOID8gdrXgPdFxII+ntOMGfdmbiKcU715myzsl01jGY8A7u7x2EumMe+EP/SYdgP5DSmQzzIZEa+PiN+Rm63ryP/BPwmY18eypnIb9x4m0Wn9jvs1c8xw/yYy+tmu6Z8lv4l4coPL0tqZ3xoi4lHAM4GTU0p3DmMZmpIZ7t9/ks8C+AbgYuBc4M5qGuQ34JoZ5rdPEfEm8qGi+6aUPplS+nxKaQ/ydwaPi3w2z1YZ62YupbSCfHjgk6Z46JPIpyy/qWv6TDUud00yvfOkDW8GjiEfAvkK4Pnk71H8imb/jn8kH2rZbWLa1Q0uS1MwwwOZyOi1XdP/VP18IJoR5re2icObPMRyRMxw/1JKq1NKryIf3ve3wGNTSs8nv+G+m/7e5KsG8zuQQ4HvpZS6P3T4KjnTWze4rEa0rrscgtOAgyNip5TS2d13RsSzyX+YDw84/uXkED2SfCreCdsOON5k9gTOTCkd1DkxIuaTP51oyjLg2RGxTtdJUP6a/OXlixtclqbHDPfn5+TvzT0c+H3H9IkvSHuNo5llfge3H3BpSuknQxpf02OGB5BSupbqQ7XI1xfbBfhpjzfJGi7z259NyWfE7ja7+tm63mms98xV3k3+ZOHD1fG194h8Ct0PkZuUdw84/reqn4d2TX/dgONN5i7u+wkFEfEy8hvWterzlKxfJAf5JR3zbwK8DPhaSqnX9+k0XGa4vwyfXP28Z4NfncXyQPIFU38+7YrVBPM7wKUJIuLJwOOBz/RbqBpnhutfXuPfyEf4/O+A82tw5re//F4MPK9zXVUfRuxFPgz10r6qngGt6y6bllL6XUQcQD5M5YKI+Dj5uN6tyW/2NiEfFzvQHyel9POI+BKwqPrD/wTYmXtP4d/UFe5PA/6zOjvQj8inY305993zMJmJU7KeCCyc4rFfJD+H4yPiCeRPOw4lf0px5ECVqxYzDPSX4VOB7wJHVB9EnE8+nfFOwKv9QGJmmV+gv/xOeHn100MsR8wMA31kOCJeAbyUfDjcSvLlYvYCPpZS+tKgxWsw5hfobxv8DuDTwE8j4iPkRnhfYEfgLSmlOwaqfojGvpkDSCl9ISJ+Qz4l+URwrwfOBN6eUrqw5iJeST7N7r7AHsAZ5LPf/JZ7zwJZ19vJF3Xcrxr7F+RrgryjofGBfBafiPh78ic0/0I+YcTPgIUppd82uSxNnxmevpRSqs449T/VchaSn8crUkq+MR4B89ufak/yPuRrfrrdbQEz3JeLgQcBbyW/h/gt8BrgIw0vR9NkfqcvpXRSRFxHXlf/Tj7D52+B16SUBj0UdagipaYaZnWKiB2A8/ANpAplhlUy86vSmWGVzPzOnPvDd+aGLiJ6XTNlEfmsTb0uwC21ihlWycyvSmeGVTLzO1r3i8MsZ8Abqotinkm+lsoLqttHUkpXjLQyaXrMsEpmflU6M6ySmd8R8jDLBkTE88gnB3kCsBH54oefAt7mhV5VAjOskplflc4Mq2Tmd7Rs5iRJkiSpQH5nTpIkSZIKZDMnSZIkSQWymZMkSZKkAtnMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKZDMnSZIkSQWymZMkSZKkAtnMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKZDMnSZIkSQWymZMkSZKkAtnMSZIkSVKBZs30AiMigM2Bm2d62SrSXODqlFIadSFgfjWQ1mTY/GoArckvmGENpDUZNr8awJT5nfFmjhziK0ewXJVrC+CqURdRMb8aRFsybH41iLbkF8ywBtOWDJtfDWKt+R1FM3czwBVXXMHGG2888CDz5s1rpJi//OUvtcd45jOf2UAl8PjHP772GLvttlsDleS/T11ve9vbGqgEaNcnWDcDHHLIIcyZM2fgQY466qhGitl6661rj7F8+fLaYwA861nPqj1GE88H4Nhjj609xjbbbNNAJfdoS4ZvBthjjz2YPXv2wIPss88+jRTzkpe8pPYYe+21VwOVwEYbbVR7jE984hMNVNKMgw8+uPYYq1ev5sQTT4T25BcaqmW//fZrYhg+85nP1B5jxYoVDVTSjCa2nQBvfetbGxmnQW3JcCN1PPGJT2xiGH71q1/VHuMBD3hAA5XANddcU3uMpnqD888/v/YY22+/fQOV3GOtuRlFMwfAxhtvXKuZa7KOutZdd90GKqHWm6sJTb2o1l9//UbGGVdz5syp1cw1lf18xEY9TdXSxOugidcAwNy5cxsZZ1zNnj271rrecMMNG6ymnvXWW69V47TFuD2fprVp/bThvdAE/+8vQ1PvO5vQxPsQaNfroLT3EJ4ARZIkSZIKNFAzFxGvjYjlEXF7RPw0Ip7edGHSsJhflc4Mq2TmV6Uzw2qTvpu5iNgbOAY4CngKcD7wrYh4aMO1SY0zvyqdGVbJzK9KZ4bVNoPsmTsc+GhK6fiU0q+B1wC3Av/YaGXScJhflc4Mq2TmV6Uzw2qVvpq5iFgP2BE4Y2JaSunu6vdmTukoDYn5VenMsEpmflU6M6w26vdslpsA6wLXdk2/FnhcrxkiYg7Qedq/sk4Ro3FiflW6vjJsftUyboNVOrfBap2ZOJvlEcCKjpsXS1RJzK9KZn5VOjOskplfDV2/zdx1wF3Apl3TNwUmu9rf0cC8jtsWfS5Taor5Ven6zbD5VZu4DVbp3Aardfpq5lJKq4GfA8+ZmBYR61S//3iSeVallG6auDHFVcylYTG/Kl2/GTa/ahO3wSqd22C1Ub/fmYN8OtYTI+Jc4BxgEbAhcHyDdUnDYn5VOjOskplflc4Mq1X6buZSSidHxEOA/wIeBiwDdkspdX8ZVGod86vSmWGVzPyqdGZYbTPInjlSSu8H3t9wLdKMML8qnRlWycyvSmeG1SYzcTZLSZIkSVLDbOYkSZIkqUCRUprZBUZsDKzYc889mT179sDjPP/5z2+knuuvv772GIcffngDlTTj+OOb+f7tiSeeWHuMjTfeuNb8d9xxB9/85jcB5lVngRq5ifw+8pGPZJ11Bv8s5NJLL22kniZevz/60Y8aqASWLVtWe4xtttmmfiHAYYcdVnuMK664ovYYKSVuu+02aEmGJ/K7wQYbEBEDj3Psscc2Us9VV11Ve4zvfve7DVQCS5curT3GaaedVr8Q4LWvfW3tMb797W/XHmPlypU89alPhZbkF+7N8KjrmPCGN7yh9hj77LNPA5XAhhtuWHuMJUuW1C8E+OAHP9jIOA1qRYYn8hsRtbbBd999dyP1rLvuurXHWLx4cf1CgLlz619P/YADDmigEnjZy15We4wzzjijgUrusdb8umdOkiRJkgpkMydJkiRJBbKZkyRJkqQC2cxJkiRJUoFs5iRJkiSpQDZzkiRJklQgmzlJkiRJKpDNnCRJkiQVyGZOkiRJkgpkMydJkiRJBbKZkyRJkqQC2cxJkiRJUoFs5iRJkiSpQDZzkiRJklQgmzlJkiRJKpDNnCRJkiQVyGZOkiRJkgoUKaWZXWDExsCKuuP84Q9/aKAa2HLLLWuP8eQnP7mBSuDwww+vPcYPf/jDBiqBBz3oQbXHOProoxuoBIB5KaWbmhqsjqbyu2DBgvrFAF/5yldqj7HVVls1UAk84hGPqD3Gy172sgYqgdmzZ9ce4wMf+EDtMe666y4uuugiaEmGJ/L7jne8g/XXX3/gcRYtWtRIPU38/zN37twGKoFbb7219hj7779/A5XArFmzao9x99131x5j9erVnHTSSdCS/EJz2+ALLriggWpgu+22qz1GE9tOgOXLlzcyTltERJPDtSLDTeW3KZtttlntMa6++uoGKmnm773jjjs2UAkceuihtcc46KCDGqjkHmvNr3vmJEmSJKlANnOSJEmSVCCbOUmSJEkqUF/NXEQcERE/i4ibI+JPEXFKRDx2WMVJTTPDKpn5VcnMr0pnhtVG/e6Z2xk4DngG8DxgNvDtiNiw6cKkITHDKpn5VcnMr0pnhtU6fZ0yK6W0W+fvEbEQ+BOwI/D95sqShsMMq2TmVyUzvyqdGVYb1f3O3Lzq51/qFiKNiBlWycyvSmZ+VTozrJEb+GI2EbEOsAT4YUrpwrU8bg4wp2NSMxcFkmqaTobNr9rK/KpkvodQ6dwGqy3q7Jk7DvgrYJ8pHncE+QKJE7crayxTatJ0Mmx+1VbmVyXzPYRK5zZYrTBQMxcR7wdeBOyaUpoqmEeTd0NP3LYYZJlSk/rIsPlV65hflcz3ECqd22C1SV+HWUZEAO8D9gB2SSldNtU8KaVVwKqOMfqtUWpMvxk2v2oT86uS+R5CpXMbrDbq9ztzxwH7AbsDN0fEw6rpK1JKtzVamTQcZlglM78qmflV6cywWqffwywPIe8mXgr8seO2d7NlSUNjhlUy86uSmV+Vzgyrdfq9zpz7h1U0M6ySmV+VzPyqdGZYbVT3OnOSJEmSpBGwmZMkSZKkAg180fC6VqxYwcYbbzzw/N/5zncaqWPLLbesPcbll1/eQCXwyle+svYYBx10UAOVwOMf//jaY+y555615r/jjjs49dRTa9cxDM997nOZPXv2wPMfeOCBjdTx5je/ufYYV1xxRQOVwKabblp7jP/7v/9roBLYdttta49x/fXX1x7j7rvvrj3GMFx99dXMmTNn6gdO4g1veEMjdTRxZrd3vvOdDVQCb3zjG2uPccIJJ9QvpCGeNW/ttttuu0bGOeSQQ2qP8YEPfKCBSuArX/lK7TE222yzBiqBM888s5FxNFy33Vb/nC0f/ehHG6gE9t67/tcODz300AYqgZ133rn2GOecc07tMVauXMnf/d3fTfk498xJkiRJUoFs5iRJkiSpQDZzkiRJklQgmzlJkiRJKpDNnCRJkiQVyGZOkiRJkgpkMydJkiRJBbKZkyRJkqQC2cxJkiRJUoFs5iRJkiSpQDZzkiRJklQgmzlJkiRJKpDNnCRJkiQVyGZOkiRJkgpkMydJkiRJBbKZkyRJkqQC2cxJkiRJUoEipTSzC4zYGFhx+OGHM2fOnBlddi8Pe9jDao9x2GGHNVBJM6644opRl3CPLbfcsqmh5qWUbmpqsDom8vvqV7+6Vn6PPfbY5oqqqaltQETUHmP+/Pn1CwG22mqr2mNss802tce44447OO2006AlGZ7Ib91xZvr/jVKcfvrpjYzzwhe+sJFxGtSK/EJzGW7KD37wg9pj7LTTTg1U0sw2uKnX9t577117jM9//vMNVHKPVmS4qfw+4xnPaKAa+MlPftLIOE1oInuHHHJIA5XAhz70oUbGadBa8+ueOUmSJEkqkM2cJEmSJBXIZk6SJEmSClSrmYuIN0VEioglDdUjzRjzq9KZYZXM/Kpk5ldtMXAzFxFPA14N/LK5cqSZYX5VOjOskplflcz8qk0GauYiYiPgJOBg4IZGK5KGzPyqdGZYJTO/Kpn5VdsMumfuOODrKaUzmixGmiHmV6UzwyqZ+VXJzK9aZVa/M0TEPsBTgKdN8/FzgM4Lcs3td5lSU8yvStdPhs2v2sZtsEpmftVGfe2Zi4gtgfcCL08p3T7N2Y4gXyBx4nZlXxVKDTG/Kt0AGTa/ag23wSqZ+VVb9XuY5Y7AQ4FfRMSdEXEnsDPwL9Xv6/aY52hgXsdtizoFSzWYX5Wu3wybX7WJ22CVzPyqlfo9zPK7wHZd044HfgO8M6V0V/cMKaVVwKqJ3yOi3xqlpphfla6vDJtftYzbYJXM/KqV+mrmUko3Axd2TouIW4DrU0oX9p5Lagfzq9KZYZXM/Kpk5ldtVeui4ZIkSZKk0ej7bJbdUkq7NFCHNBLmV6UzwyqZ+VXJzK/awD1zkiRJklQgmzlJkiRJKlDtwywHdcwxx9Saf5tttmmkjve85z21x9hkk00aqASOPvro2mPcddcaJ1MayPe///1GxhlXH/7wh2vNf9BBBzVSx4477lh7jKbOrjV//vzaYzTxGgDYaKONao+x//77N1DJeJo3b14j46xYsaL2GJ/61KcaqKSZv/emm27aQCXN+Ld/+7faY6xatYr3ve99DVTTPimlRsZpYvv50Ic+tIFKYMMNN2xknCZccskltce46KKLao+xcuVKnva0aV3fuyg/+clPGhmnidfBxz72sQYqydubuj70oQ81UAlsueWWtcdo4v+Du+66i/POO2/Kx7lnTpIkSZIKZDMnSZIkSQWymZMkSZKkAtnMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKZDMnSZIkSQWymZMkSZKkAtnMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKNGvUBQzq0ksvbWScBQsW1B5j3rx59QsBjjvuuNpj7Lbbbg1UAhtssEEj44yr2bNnExEDz/+d73ynkTo+9rGP1R5j7ty5DVQC+++/f+0xtt122wYqgdNPP72RcdTbTTfdNOoS7vGpT32qkXFe+cpXNjJOEzbeeOPaYzTxf+Qdd9xRe4y2qrP97pRSqj1GU7U04fzzz29knEMPPbT2GI95zGNqj9GmbVWnuu8hVq9e3WA19fzgBz9oZJxXvepVjYzThLe97W21x5jJ/1PcMydJkiRJBbKZkyRJkqQC2cxJkiRJUoH6buYi4uER8emIuD4ibouICyLiqcMoTmqa+VXpzLBKZn5VOjOstunrBCgR8UDgh8CZwAuAPwOPBm5ovjSpWeZXpTPDKpn5VenMsNqo37NZvhG4IqV0YMe0yxqsRxom86vSmWGVzPyqdGZYrdPvYZb/AJwbEV+IiD9FxHkRcfAwCpOGwPyqdGZYJTO/Kp0ZVuv028w9CjgE+B3wfOCDwLERccBkM0TEnIjYeOIGNHNRK6l/5lel6yvD5lct4zZYpXMbrNbp9zDLdYBzU0pvrn4/LyL+CngNcOIk8xwBHDlgfVKTzK9K12+Gza/axG2wSuc2WK3T7565PwK/7pp2EbDVWuY5GpjXcduiz2VKTTG/Kl2/GTa/ahO3wSqd22C1Tr975n4IPLZr2mOAyyebIaW0Clg18XtE9LlIqTHmV6XrK8PmVy3jNlilcxus1ul3z9z/Ac+IiDdHxLYRsR/wT8BxzZcmNc78qnRmWCUzvyqdGVbr9NXMpZR+BuwB7AtcCLwVWJRSOmkItUmNMr8qnRlWycyvSmeG1Ub9HmZJSuk04LQh1CINnflV6cywSmZ+VTozrLbp9zBLSZIkSVIL2MxJkiRJUoEipTSzC8wXTVxRd5yjjz66gWpg9erVtcd4xzve0UAlcOutt9Yeo6kzJd1xxx21x5g9e3YDlQAwL6V0U1OD1TGR3+c85znMmtX3Ucr3+Na3vtVIPU1k741vfGMDlcDKlStrj3HFFVc0UAk84QlPqD3GIYccUnuM1atX8/GPfxxakuGJ/H7zm99kww03HHicZz/72Y3Uc8kll9Qe4zOf+UwDlcD73//+2mMsXLiwfiHAu971rkbGaVAr8gv3Znjbbbdl3XXXHXic3/72t43U8+IXv7j2GL/73e8aqAQuuuii2mNcfPHFDVQCy5Ytqz3G3nvvXb+Qe7Uiw029B57p9+4zYf/99689xgYbbNBAJfC5z32u9hi333577TFSShPvx9eaX/fMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKZDMnSZIkSQWymZMkSZKkAtnMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKZDMnSZIkSQWymZMkSZKkAs0adQGDuv322xsZZ/Xq1bXHSCk1UAncdNNNjYzThDbV0kZ33nnnqEsAmnkdNPW3XrlyZSvGaEoT24YmxhiGW265ZdQlAHDzzTfXHqOp/wvuvvvu2mOsWrWqgUo0HU38vZpwxx131B7jrrvuaqCSZrblTW2Db7311kbGUW/j+B6tif8vZ81qpq1p4n39TI4RTTUi0xURDweunNGFqnRbpJSuGnURYH41sFZk2PxqQK3IL5hhDawVGTa/GtBa8zuKZi6AzYHJPpKdSw76Fmt5jAZX2vqdC1ydZjqok5hGfqG8dVySEtdtazJsfluhtPXbmvyCGW6BEtdtazJsfkeuxHU7ZX5n/DDLqpjJu8uIiX/enFIav/3II1bg+m1VjVPlF4pcx8UodN22pk7zO3oFrt9W1WiGR6vQdduaOs3vaBW6bqes0xOgSJIkSVKBbOYkSZIkqUBtbOZWAUdVP9U81+/wuY6Hx3U7fK7j4XL9Dp/reHhct8PnOh6esVy3M34CFEmSJElSfW3cMydJkiRJmoLNnCRJkiQVyGZOkiRJkgpkMydJkiRJBWpdMxcRr42I5RFxe0T8NCKePuqaShcRiyMidd1+M+q6xpH5HQ4zPHPMcPPM78wxv8NhhmeG+R2Occ9vq5q5iNgbOIZ82tCnAOcD34qIh460sPHwK2CzjttOoy1n/JjfoTPDQ2aGh8r8Dpn5HTozPETmd+jGNr+tauaAw4GPppSOTyn9GngNcCvwj6MtayzcmVK6puN23agLGkPmd7jM8PCZ4eExv8NnfofLDA+X+R2usc1va5q5iFgP2BE4Y2JaSunu6vdnjqquMfLoiLg6In4fESdFxFajLmicmN8ZYYaHyAwPnfkdIvM7I8zwkJjfGTG2+W1NMwdsAqwLXNs1/VrgYTNfzlj5KbAQ2A04BHgk8IOImDvKosaM+R0uMzx8Znh4zO/wmd/hMsPDZX6Ha6zzO2vUBWj4Ukrf6Pj1lxHxU+ByYC/g46OpSpo+M6ySmV+VzgyrZOOe3zbtmbsOuAvYtGv6psA1M1/O+Eop3QhcDGw74lLGifmdQWZ4KMzwDDG/Q2F+Z5AZbpz5nUHjlt/WNHMppdXAz4HnTEyLiHWq3388qrrGUURsBGwD/HHUtYwL8zuzzHDzzPDMMb/NM78zyww3y/zOrHHLb9sOszwGODEizgXOARYBGwLHj7Ko0kXEe4CvkXcpb04+7e1dwGdHWdcYMr9DYoZnjBkeAvM7Y8zvkJjhGWF+h2Tc89uqZi6ldHJEPAT4L/IXPpcBu6WUur8Qqv5sQQ7sg4E/A2cDz0gp/XmkVY0Z8ztUZngGmOGhMb8zwPwOlRkeMvM7VGOd30gpjboGSZIkSVKfWvOdOUmSJEnS9NnMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKZDM3AyJiaUQsHXUd0qDMsEpmflU6M6ySmd/hspmrRMTCiEgRcXtEPLzH/Usj4sJR1NaUiHh8RHwzIlZGxF8i4lMR8ZBR16Vm3E8yvE5EHBIRyyLitoi4PiK+FxHbj7o21TPu+a2e22S374y6PtU37hkGiIh/joiLImJVRFwVEcdExIajrkv13U/yu1dE/CQibqzeP5wVES8cdV11zRp1AS00B3gT8LoGx/x/DY41kIjYAvg+sAJ4M7AR8G/AdhHx9JTS6lHWp0aNZYYrnwBeDnwSeD+wIfBk4KGjLEqNGtf87t9j2lOBw4Bvz3AtGq6xzHBEvBN4A/BF4L3AE8jP8YnA80dYmpo1rvl9HXAs8HXy81sfWAicFhEvTSl9eYTl1WIzt6ZlwMERcXRK6eomBmxJo/Rm8hvfHVNKfwCIiHOA75DD/JHRlaaGLWMMMxwRewEHAC9JKX1l1PVoaJYxhvlNKX26e1pE7AIk4LMzXY+GahljluGI2Aw4HPhUSumVHdMvBt4XES9OKX1tZAWqScsYs/xWXgf8DHhxSikBRMQngKvI7y2KbeY8zHJNbwfWJXftaxURsyLirRFxaXXIwfKIeHtEzOl63BrHCkfE6yLiVxFxa0TcEBHnRsR+1X27Vru69+ixzP2q+54ZEfMi4nERMW8az+ulwGkTjRxASukM4GJgr2nMr3KMa4YPB85JKX2lOtzSQ3vG07jmt3ucOeTt8lkppSv7nV+tNo4ZfiZ5B8DnuqZP/L7PVM9VxRjH/AJsDPxpopEDSCndBKwEbpvG/K1lM7emy8iHcB0cEZtP8diPAf8F/AJ4PXAWcARrbuzuIyIOJu/q/TWwCDiS/EnIX1cPWQpcQT6crNvLgUtTSj8G9gAuqn6ubXkPJx+Gdm6Pu88hH6am8TGOGd4YeDrws4h4O/lw4ZUR8fvIe+w0PsYuv5P4e2A+cNIA86rdxjHDE2/Ou9/03lr93HGK+VWOcczvxJi7VU3k1lUTeBwwj3zYcLlSSt5yk76QfLjLU4FHAXcA7+24fylwYcfv21eP/2jXOO+upu/aNe/Sjt9P6RxrknreDtwOzOuY9pCqrsVdNS+cYqynVo/bv8d976rumzPqv4G3ercxz/CTq8ddB1wDHALsB/wUuBvYbdTr31u92zjnd5Lxv1iNP3/U695bM7dxzjDwlOpxb+ma/vxq+s2jXv/e6t3GOb/VYx8KnFE9fuL2Z+CZo173dW/umeshpfR74FPAP0U+TryXv69+HtM1/X+rn2s7O86NwBYR8bS1POaT5E/C9uyYtjf5MIdPV3WekFKKlNIJaxkH4AHVz1U97ru96zEaA2OY4Y2qnw8Gdk8pfTCl9BngOcD1wFummF8FGcP83ke1p/mFwOkppRv7mVdlGLcMp5R+Qf7w7I0RcWC1Z+MFwIfJb659DzFGxi2/lVuB3wInAi8D/hH4I/DliNh2GvO3ls3c5P6HHJjJjhl+BHmPwCWdE1NK15BD+oi1jP1O8jG650TE7yLiuIj4m65xfkP+ombnLuaXAz9JKd1nmdMwcVjEnB73rd/1GI2PcczwZSmln3YsYyXwNeDpEeEJncbLOOW320vJ214PsRxv45bhlwLnk88qfBl52/t54LyqFo2XccvvF4CtUkoLU0pfTCkdD+wCrAe8bYDxWsNmbhLVpxKfZu2fSkDeTdvv2BcBjyV/Yfhs8gby7Ig4quuhnwR2jogtImIb4BlVTf36Y/Wz1/PYDPhLSqnXXjsVbMwyPHFGrWt73PcnYDb5bK0aE2OW324vJ3/v87QGxlJLjVuGU0pXpZR2Ah4D/C2wRUrpDcCW5JOpaYyMU34j4lHAbsBXu+r4S7X8v+k1Xyls5tZu4lOJN/a473Ly+nt058SI2JT8pfbL1zZwSumWlNLJKaUDga3I1734j4hYv+NhnwPuAvYl/+d/B3Byv08ipXQV+bjgp/a4++nkL51qPI1Lhq8mf1dujQuZApuTDxe+ud9x1Xpjkd+u+jYDdgW+5Ido9wtjl+GU0u9SSj9IKV0TEU8gfyh8Rp0x1Vrjkt9Nq5/r9rhvNoVfqs1mbi1SSpeSPwF4NfCwrrtPr34u6pp+ePXz65ONGxEP7lrOavIZfYIcqonp1wHfAF5BDvE3q2kT4/RzStYvAS+KiC075n8O+RO2L0xjfhVozDJ8MrBlRDyvY/5NgN2B76WU7p7GGCrImOV3wj7k/3s9xPJ+YEwzPDHvOuSTqN0KfKjf+dV+Y5TfS8iHhO4dEdEx/xbAs8mHCher6E50hrwN2J+8O/hXExNTSudHxInk3c/zyadjfTr5woOnpJTOXMuY346Ia4Afkg8bezzwz8DXU0rdexc+ST7rGcBbu+7bAzgeOBA4YYrn8XbyFz7PjIj3kk8o8e/ABdUYGl/jkuGjyddE/FJEHEM+TO015A3/m6eYV+Ual/xOeDn5sOGl03y8yjcWGa7eO6xPPppnNvmMwk8HDkgd17DV2Ck+vymlP0e+QPirgO9GxJeBucCh5JP3HL2WWlvPZm4KKaVLIuLT5HB2exXwe/KpUfcgHwZ2NNB9zG+3D5P/Qz+c3FRdSb7exv/0eOzXgBvIn+R+tcf905JSuiIidiafdegdwGrypyb/6qE+422MMnxtROwEvId8PZvZwI+BV6SUzh90XLXbuOQXICIeS74e1zHuSb7/GKMMn0feC/Ny8l6Oc4DnTPGmXYUbo/weQj6Bz0Hc27z9DHhlSun7NcYduUip7+8tagZVZ+i7GvhaSumgUdcj9csMq2TmV6UzwyqZ+Z2a35lrvwXkiyR+csR1SINagBlWuRZgflW2BZhhlWsB5net3DPXUhHx18CTyMcHX5dSesqIS5L6YoZVMvOr0plhlcz8Tp975trrEOCD5GtovXLEtUiDMMMqmflV6cywSmZ+p8k9c5IkSZJUIPfMSZIkSVKBbOYkSZIkqUA2c5IkSZJUIJs5SZIkSSqQzZwkSZIkFchmTpIkSZIKZDMnSZIkSQWymZMkSZKkAtnMSZIkSVKB/j+ZXF3l1YwsSwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "x_train_anomalous = training_data[0].copy()\n", "y_train_anomalous = training_data[1].copy()\n", @@ -408,8 +556,8 @@ "\n", "fig, axes = plt.subplots(2, 5, figsize=(9, 5))\n", "for i in range(5):\n", - " axes[0, i].imshow(np.reshape(current_images[i], (8, 8)), cmap=\"grey\")\n", - " axes[1, i].imshow(np.reshape(noisy_images[i], (8, 8)), cmap=\"grey\")\n", + " axes[0, i].imshow(np.reshape(current_images[i], (8, 8)), cmap=\"gray\")\n", + " axes[1, i].imshow(np.reshape(noisy_images[i], (8, 8)), cmap=\"gray\")\n", " axes[0, i].set_xlabel(f\"Original: {training_data[1][indices[i]]}\")\n", " axes[1, i].set_xlabel(f\"Noisy: {training_data[1][indices[i]]}\")\n", "plt.suptitle(\"Original and noisy versions of images 6-10\")\n", @@ -419,9 +567,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "from scipy.stats import norm\n", "\n", @@ -511,9 +683,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average value of original data points: 0.6300257540520159\n", + "Average value of modified, anomalous data points: 0.07210118735126189\n", + "For reference, these are the average data values of all data points used for training (anomalous):\n", + "data_value 0.022450\n", + "data_value_stderr 0.083306\n", + "dtype: float64\n", + "These are the average data values of all points (original data):\n", + "data_value -0.016296\n", + "data_value_stderr 0.118257\n", + "dtype: float64\n" + ] + } + ], "source": [ "print(\n", " f\"Average value of original data points: {plot_data['original_data_value'].mean()}\"\n", @@ -542,9 +731,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/100 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
data_valuedata_value_stderr
136-0.0955750.049190
142-0.0872620.043481
187-0.0853640.046185
22-0.0812510.039468
5-0.0803460.041551
\n", + "" + ], + "text/plain": [ + " data_value data_value_stderr\n", + "136 -0.095575 0.049190\n", + "142 -0.087262 0.043481\n", + "187 -0.085364 0.046185\n", + "22 -0.081251 0.039468\n", + "5 -0.080346 0.041551" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "msr_df.head()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "high_dvl = df.iloc[-30:]\n", "high_dvl.index = high_dvl.index.map(str)\n", @@ -590,9 +873,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "low_dvl = df.iloc[:30]\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -611,12 +907,14 @@ "source": [ "### Compare convergence speed of Banzhaf and MSR Banzhaf Values\n", "\n", - "While the conventional Banzhaf values algorithm evaluates the utility twice to do one update of the Banzhaf values, the Maximum Samples Reuse (MSR) algorithm promises higher sample efficiency because it updates multiple samples per one evaluation of the utility. This part of the notebook takes a look at the convergence speed of the algorithms compared with each other." + "While the conventional Banzhaf values algorithm evaluates the utility twice to do one update of the Banzhaf values, the Maximum Samples Reuse (MSR) algorithm promises higher sample efficiency because it updates multiple samples per one evaluation of the utility. This part of the notebook takes a look at the convergence speed of the algorithms compared with each other. \n", + "\n", + "To analyze this, we will compute the semivalues using different samplers and use a high number of iterations to make sure that the values are converged." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -630,7 +928,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -652,7 +950,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -680,9 +978,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Compare convergence speed of both methods\n", "import numpy as np\n", @@ -787,19 +1146,124 @@ "After 1000 iterations (subsets tried), Monte Carlo Banzhaf has evaluated the marginal function about 5 times per data point (we are using 200 data points). \n", "For maximum sample reuse, the semivalue of each data point was updated 1000 times. Due to this, the values converge much quicker, which is one of the advantages of MSR sampling. \n", "\n", - "MSR sampling does come at a cost, however, which we will visualize in the next plot. The semivalues that MSR converges to are less consistent." + "MSR sampling does come at a cost, however, which is that the updates to the semivalues are more noisy than in other methods. \n", + "We will analyze the impact of this tradeoff in the next sections. \n", + "First, let us analyze how similar all the computed semivalues are. They are all Banzhaf values, so in a perfect world, all samplers should result in the exact same semivalues. However, due to randomness in the utility (it is a neural network) and randomness in the samplers, the resulting values are likely never exactly the same. \n", + "Another quality measure is that a good sampler would lead to very consistent values, a bad one to less consistent values. \n", + "Let us analyze how similar the samplers are first, then look at consistency." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Similarity of the semivalues computed using different samplers" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ - "from scipy.stats import spearmanr\n", + "names = [\"Permutation\", \"MSR\", \"Uniform\", \"Antithetic\", \"RandomHierarchical\"]\n", + "values = [\n", + " permutation_values,\n", + " msr_values,\n", + " uniform_values,\n", + " antithetic_values,\n", + " random_values,\n", + "]\n", + "top_consistency = np.zeros((len(names), len(names)))\n", + "low_consistency = np.zeros((len(names), len(names)))\n", + "twenty_percent = training_data[0].shape[0] // 5\n", + "\n", + "for sampler1_id, sampler1_values in enumerate(values):\n", + " for sampler2_id, sampler2_values in enumerate(values):\n", + " sampler1_values.sort(key=\"value\")\n", + " sampler2_values.sort(key=\"value\")\n", + " top_20_1 = set(sampler1_values.indices[-twenty_percent:].tolist())\n", + " lower_20_1 = set(sampler1_values.indices[:twenty_percent].tolist())\n", + " top_20_2 = set(sampler2_values.indices[-twenty_percent:].tolist())\n", + " lower_20_2 = set(sampler2_values.indices[:twenty_percent].tolist())\n", + " top_consistency[sampler1_id, sampler2_id] = len(top_20_1.intersection(top_20_2))\n", + " low_consistency[sampler1_id, sampler2_id] = len(\n", + " lower_20_1.intersection(lower_20_2)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fix, axes = plt.subplots(1, 2, figsize=(10, 5))\n", + "axes[0].matshow(top_consistency, vmin=0, vmax=twenty_percent)\n", + "mat2 = axes[1].matshow(low_consistency, vmin=0, vmax=twenty_percent)\n", + "axes[0].set_xticks(np.arange(len(names)), names, rotation=90)\n", + "axes[1].set_xticks(np.arange(len(names)), names, rotation=90)\n", + "for (i, j), z in np.ndenumerate(top_consistency):\n", + " axes[0].text(j, i, f\"{int(z)}\", ha=\"center\", va=\"center\", c=\"white\")\n", + "for (i, j), z in np.ndenumerate(low_consistency):\n", + " axes[1].text(j, i, f\"{int(z)}\", ha=\"center\", va=\"center\", c=\"white\")\n", + "\n", + "axes[0].set_yticks(np.arange(len(names)), names)\n", + "axes[1].set_yticks(np.arange(len(names)), names)\n", + "axes[0].set_title(\"Top 20% of points\")\n", + "axes[1].set_title(\"Low 20% of points\")\n", + "fig.colorbar(mat2)\n", + "plt.suptitle(\"Overlapping high and low value points between samplers\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This plot shows that the samplers lead to quite different Banzhaf semivalues, however, all of them have some points in common. \n", + "The MSR Sampler does not seem to be significantly worse than any others. \n", "\n", - "print(\"Similarity of the ranking of Permutation Sampler and MSR Sampler semivalues:\")\n", - "print(spearmanr(permutation_values.values, msr_values.values))" + "In an ideal setting without randomness, the overlap of points would be higher, however, the stochastic nature of the CNN model that we use together with the\n", + "fact that we use only 200 data points for training, might overshadow these results. " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of top 20 points that all samplers have in common: 1\n" + ] + } + ], + "source": [ + "all_in_common = set(permutation_values.indices.tolist())\n", + "for sampler_id, sampler_values in enumerate(values):\n", + " sampler_values.sort(key=\"value\")\n", + " top_20 = set(sampler_values.indices[-twenty_percent:].tolist())\n", + " all_in_common = all_in_common.intersection(top_20)\n", + "print(\n", + " f\"Total number of top 20 points that all samplers have in common: {len(all_in_common)}\"\n", + ")" ] }, { @@ -814,7 +1278,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -826,9 +1290,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/45 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Plot results\n", "\n", @@ -927,7 +1452,11 @@ "metadata": {}, "source": [ "**Conclusion:**\n", - "MSR" + "MSR sampling updates the semivalue estimates a lot more frequently than any other sampler available, which leads to a lot **faster convergence**. \n", + "Additionally, the sampler is more consistent with its value estimates than the other samplers, which might be caused by the higher number of value updates. \n", + "\n", + "In general, the recommendation is to try different samplers when computing semivalues and test, which one is best suited for your use case. The MSR sampler\n", + "seems like a more efficient sampler which may bring fast results and is well-suited for stochastic models." ] } ], diff --git a/tox.ini b/tox.ini index 499bd1996..600c8dc14 100644 --- a/tox.ini +++ b/tox.ini @@ -24,7 +24,7 @@ deps = {[testenv]deps} -r requirements-notebooks.txt commands = - pytest --nbmake --nbmake-timeout=60 -n 0 --cov "{envsitepackagesdir}/pydvl" notebooks/ {posargs} + pytest --nbmake --nbmake-timeout=90 -n 0 --cov "{envsitepackagesdir}/pydvl" notebooks/ {posargs} [testenv:linting] skip_install = true From dca88a7906127f380cae9636a28f98451ea03d7f Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Tue, 9 Apr 2024 00:36:39 +0200 Subject: [PATCH 31/42] Some tweaks to notebook text and supporting code --- notebooks/msr_banzhaf_digits.ipynb | 290 +++++++++++++++-------------- notebooks/support/banzhaf.py | 65 +++++++ 2 files changed, 214 insertions(+), 141 deletions(-) diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb index ff653d7c1..1e37ce9a3 100644 --- a/notebooks/msr_banzhaf_digits.ipynb +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -4,20 +4,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Banzhaf Values for data valuation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Similar to the Shapley values notebook, this notebook shows how to compute Banzhaf values using pyDVL.\n", - "Banzhaf semivalues achieve a higher safety margin when compared with other methods like Shapley or LOO semivalues.\n", + "# Banzhaf Semi-values for data valuation\n", + "\n", + "This notebook showcases [Data Banzhaf: A Robust Data Valuation Framework for Machine Learning](https://proceedings.mlr.press/v206/wang23e.html) by Wang, and Jia.\n", "\n", - "This notebook compares two sampling techniques for computing Banzhaf semivalues, a simple Monte Carlo sampling technique\n", - "and another sampling technique using the MSR (Maximum Sample Reuse) principle. We also compare both techniques in this notebook.\n", + "Computing Banzhaf semi-values using pyDVL follows basically the same procedure as all other semi-value-based methods like Shapley values. However, Data-Banzhaf tends to be more robust to stochasticity in the training process than other semi-values. A property that we study here.\n", "\n", - "In this notebook, we will use a CNN to classify handwritten digits from the [scikit-learn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html#optical-recognition-of-handwritten-digits-dataset)." + "Additionally, we compare two sampling techniques: the standard permutation-based Monte Carlo sampling, and the so-called MSR (Maximum Sample Reuse) principle.\n", + "\n", + "In order to highlight the strengths of Data-Banzhaf, we require a stochastic model. For this reason, we use a CNN to classify handwritten digits from the [scikit-learn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html#optical-recognition-of-handwritten-digits-dataset)." ] }, { @@ -41,7 +36,11 @@ "metadata": { "tags": [ "hide" - ] + ], + "ExecuteTime": { + "end_time": "2024-04-08T14:22:52.254834Z", + "start_time": "2024-04-08T14:22:52.233863Z" + } }, "outputs": [], "source": [ @@ -54,7 +53,11 @@ "metadata": { "tags": [ "hide" - ] + ], + "ExecuteTime": { + "end_time": "2024-04-08T14:22:52.920403Z", + "start_time": "2024-04-08T14:22:52.256226Z" + } }, "outputs": [], "source": [ @@ -66,7 +69,6 @@ "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from sklearn.metrics import accuracy_score\n", "\n", "plt.ioff() # Prevent jupyter from automatically plotting\n", "plt.rcParams[\"figure.figsize\"] = (20, 6)\n", @@ -93,8 +95,22 @@ { "cell_type": "code", "execution_count": 3, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2024-04-08T14:22:55.166766Z", + "start_time": "2024-04-08T14:22:53.929035Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/miguel/devel/tfl/pydvl/src/pydvl/parallel/config.py:31: FutureWarning: The `ParallelConfig` class was deprecated in v0.9.0 and will be removed in v0.10.0\n", + " warnings.warn(\n" + ] + } + ], "source": [ "%autoreload\n", "from pydvl.reporting.plots import plot_shapley\n", @@ -106,9 +122,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Loading and grouping the dataset\n", + "## Loading the dataset\n", "\n", - "pyDVL provides a support function for this notebook, `load_digits_dataset()`, which downloads the data and prepares it for usage. The data consists of grayscale images of shape 8x8 pixels with 16 shades of gray. These images contain handwritten digits from 0 to 9." + "We use a support function, `load_digits_dataset()`, which downloads the data and prepares it for usage. It returns four arrays that we then use to construct a [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset). The data consists of grayscale images of shape 8x8 pixels with 16 shades of gray. These images contain handwritten digits from 0 to 9." ] }, { @@ -119,9 +135,30 @@ "slideshow": { "slide_type": "" }, - "tags": [] + "tags": [], + "ExecuteTime": { + "end_time": "2024-04-08T14:22:58.625795Z", + "start_time": "2024-04-08T14:22:58.601936Z" + } }, - "outputs": [], + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "PyTorch is required in order to load the Digits Dataset", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mModuleNotFoundError\u001B[0m Traceback (most recent call last)", + "File \u001B[0;32m~/devel/tfl/pydvl/notebooks/support/banzhaf.py:21\u001B[0m, in \u001B[0;36mload_digits_dataset\u001B[0;34m(test_size, val_size, random_state)\u001B[0m\n\u001B[1;32m 20\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m---> 21\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mtorch\u001B[39;00m\n\u001B[1;32m 22\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mImportError\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n", + "\u001B[0;31mModuleNotFoundError\u001B[0m: No module named 'torch'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001B[0;31mRuntimeError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[4], line 1\u001B[0m\n\u001B[0;32m----> 1\u001B[0m training_data, _, test_data \u001B[38;5;241m=\u001B[39m \u001B[43mload_digits_dataset\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 2\u001B[0m \u001B[43m \u001B[49m\u001B[43mtest_size\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;241;43m0.3\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrandom_state\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mrandom_state\u001B[49m\n\u001B[1;32m 3\u001B[0m \u001B[43m)\u001B[49m\n", + "File \u001B[0;32m~/devel/tfl/pydvl/notebooks/support/banzhaf.py:23\u001B[0m, in \u001B[0;36mload_digits_dataset\u001B[0;34m(test_size, val_size, random_state)\u001B[0m\n\u001B[1;32m 21\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mtorch\u001B[39;00m\n\u001B[1;32m 22\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mImportError\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[0;32m---> 23\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mRuntimeError\u001B[39;00m(\n\u001B[1;32m 24\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mPyTorch is required in order to load the Digits Dataset\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 25\u001B[0m ) \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01me\u001B[39;00m\n\u001B[1;32m 27\u001B[0m digits_bunch \u001B[38;5;241m=\u001B[39m load_digits(as_frame\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m)\n\u001B[1;32m 28\u001B[0m x, x_test, y, y_test \u001B[38;5;241m=\u001B[39m train_test_split(\n\u001B[1;32m 29\u001B[0m digits_bunch\u001B[38;5;241m.\u001B[39mdata\u001B[38;5;241m.\u001B[39mvalues \u001B[38;5;241m/\u001B[39m \u001B[38;5;241m16.0\u001B[39m,\n\u001B[1;32m 30\u001B[0m digits_bunch\u001B[38;5;241m.\u001B[39mtarget\u001B[38;5;241m.\u001B[39mvalues,\n\u001B[1;32m 31\u001B[0m train_size\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m1\u001B[39m \u001B[38;5;241m-\u001B[39m test_size,\n\u001B[1;32m 32\u001B[0m random_state\u001B[38;5;241m=\u001B[39mrandom_state,\n\u001B[1;32m 33\u001B[0m )\n", + "\u001B[0;31mRuntimeError\u001B[0m: PyTorch is required in order to load the Digits Dataset" + ] + } + ], "source": [ "training_data, _, test_data = load_digits_dataset(\n", " test_size=0.3, random_state=random_state\n", @@ -206,13 +243,9 @@ "source": [ "## Creating the utility and computing Banzhaf semivalues\n", "\n", - "Now we can calculate the contribution of each group to the model performance.\n", - "\n", - "As a model, we use scikit-learn's [GradientBoostingRegressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html), but pyDVL can work with any model from sklearn, xgboost or lightgbm. More precisely, any model that implements the protocol [pydvl.utils.types.SupervisedModel](../../api/pydvl/utils/types/#pydvl.utils.types.SupervisedModel), which is just the standard sklearn interface of `fit()`,`predict()` and `score()` can be used to construct the utility.\n", - "\n", - "The third and final component is the scoring function. It can be anything like accuracy or $R^2$, and is set with a string from the [standard sklearn scoring methods](https://scikit-learn.org/stable/modules/model_evaluation.html). Please refer to that documentation on information on how to define your own scoring function.\n", + "Now we can calculate the contribution of each training sample to the model performance. First we need a model and a [Scorer](../../api/pydvl/utils/score/#pydvl.utils.score.Scorer).\n", "\n", - "We group dataset, model and scoring function into an instance of [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility)." + "As a model, we use a simple CNN written torch, and wrapped into an object to convert numpy arrays into tensors (as of v0.9.0 valuation methods in pyDVL work only with numpy arrays). Note that any model that implements the protocol [pydvl.utils.types.SupervisedModel](../../api/pydvl/utils/types/#pydvl.utils.types.SupervisedModel), which is just the standard sklearn interface of `fit()`,`predict()` and `score()` can be used to construct the utility." ] }, { @@ -231,75 +264,29 @@ ], "source": [ "import torch\n", - "from torch import nn, optim\n", - "from torch.utils.data import TensorDataset, DataLoader\n", - "from numpy.typing import NDArray\n", - "from pydvl.utils.types import SupervisedModel\n", + "from support.banzhaf import TorchCNNModel\n", "\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "\n", - "\n", - "class TorchCNNModel(SupervisedModel):\n", - " def __init__(self, lr=0.001, epochs=40, batch_size=32):\n", - " self.lr = lr\n", - " self.batch_size = batch_size\n", - " self.model = nn.Sequential(\n", - " nn.Conv2d(\n", - " out_channels=8, in_channels=1, kernel_size=(3, 3), padding=\"same\"\n", - " ),\n", - " nn.Conv2d(\n", - " out_channels=4, in_channels=8, kernel_size=(3, 3), padding=\"same\"\n", - " ),\n", - " nn.MaxPool2d(kernel_size=2),\n", - " nn.Flatten(),\n", - " nn.Linear(in_features=64, out_features=32),\n", - " nn.Linear(in_features=32, out_features=10),\n", - " nn.Softmax(dim=1),\n", - " )\n", - " self.loss = nn.CrossEntropyLoss()\n", - " self.optimizer = optim.Adam(self.model.parameters(), lr=lr)\n", - " self.epochs = epochs\n", - " self.model.to(device)\n", - "\n", - " def fit(self, x: NDArray, y: NDArray) -> None:\n", - " torch_dataset = TensorDataset(\n", - " torch.tensor(\n", - " np.reshape(x, (x.shape[0], 1, 8, 8)), dtype=torch.float, device=device\n", - " ),\n", - " torch.tensor(y, device=device),\n", - " )\n", - " torch_dataloader = DataLoader(torch_dataset, batch_size=self.batch_size)\n", - " for epoch in range(self.epochs):\n", - " for features, labels in torch_dataloader:\n", - " pred = self.model(features)\n", - " loss = self.loss(pred, labels)\n", - " loss.backward()\n", - " self.optimizer.step()\n", - "\n", - " def predict(self, x: NDArray) -> NDArray:\n", - " pred = self.model(\n", - " torch.tensor(\n", - " np.reshape(x, (x.shape[0], 1, 8, 8)), dtype=torch.float, device=device\n", - " )\n", - " )\n", - " pred = torch.argmax(pred, dim=1)\n", - " return pred.cpu().numpy()\n", - "\n", - " def score(self, x: NDArray, y: NDArray) -> float:\n", - " pred = self.predict(x)\n", - " acc = accuracy_score(pred, y)\n", - " return acc\n", - "\n", - " def get_params(self, deep: bool = False):\n", - " return {\"lr\": self.lr, \"epochs\": self.epochs}\n", - "\n", - "\n", - "model = TorchCNNModel(lr=0.001, epochs=40)\n", + "model = TorchCNNModel(lr=0.001, epochs=40, batch_size=32, device=device)\n", "model.fit(x=training_data[0], y=training_data[1])\n", + "\n", "print(f\"Train Accuracy: {model.score(x=training_data[0], y=training_data[1]):.3f}\")\n", "print(f\"Test Accuracy: {model.score(x=test_data[0], y=test_data[1]):.3f}\")" ] }, + { + "cell_type": "markdown", + "source": [ + "The final component is the scoring function. It can be anything like accuracy or $R^2$, and is set with a string from the [standard sklearn scoring methods](https://scikit-learn.org/stable/modules/model_evaluation.html). Please refer to that documentation on information on how to define your own scoring function.\n", + "\n", + "We group dataset, model and scoring function into an instance of [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility) and compute the Banzhaf semi-values. We take all defaults, and choose to stop computation using the [MaxChecks](../../api/pydvl/value/stopping/#pydvl.value.stopping.MaxChecks) stopping criterion, which terminates after a fixed number of calls to it. With the default `batch_size` of 1 this means that we will retrain the model.\n", + "\n", + "Note how we enable caching using memcached (assuming memcached runs with the default configuration for localhost). This is necessary in the current preliminary implementation of [permutation sampling](../../api/pydvl/value/sampler/#pydvl.value.sampler.PermutationSampler), which is the default for [compute_banzhaf_semivalues](../../api/pydvl/value/semivalues#pydvl.value.semivalues.compute_banzhaf_semivalues)." + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", "execution_count": 9, @@ -317,24 +304,27 @@ } ], "source": [ + "from pydvl.utils import MemcachedCacheBackend, MemcachedClientConfig\n", + "\n", "# Compute regular Banzhaf semivalue\n", "utility = Utility(\n", " model=TorchCNNModel(),\n", " data=dataset,\n", " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", + " cache_backend=MemcachedCacheBackend(MemcachedClientConfig())\n", ")\n", "values = compute_banzhaf_semivalues(\n", " utility, done=MaxChecks(max_checks), n_jobs=n_jobs, progress=True\n", ")\n", "values.sort(key=\"value\")\n", - "df = values.to_dataframe(column=\"data_value\", use_names=True)" + "df = values.to_dataframe(column=\"banzhaf_value\", use_names=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's take a look at the returned dataframe:" + "The returned dataframe contains the mean and variance of the Monte Carlo estimates for the values:" ] }, { @@ -419,7 +409,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let us plot the results. In the next cell we will take the 30 images with the lowest score and plot their values with 95% Normal confidence intervals. Keep in mind that Monte Carlo Banzhaf is typically very noisy, and it can take many steps to arrive at a clean estimate." + "Let us plot the results. In the next cell we will take the 30 images with the lowest score and plot their values with 95% Normal confidence intervals. Keep in mind that Permutation Monte Carlo Banzhaf is typically very noisy, and it can take many steps to arrive at a clean estimate." ] }, { @@ -468,9 +458,9 @@ "source": [ "## Evaluation on anomalous data\n", "\n", - "An interesting usecase for data valuation is finding anomalous data. Maybe some of the data is really noisy or has been mislabeled. To simulate this, we will change some of the labels of our dataset and add noise to some others. Intuitively, these anomalous data points should then have a lower value.\n", + "An interesting use-case for data valuation is finding anomalous data. Maybe some of the data is really noisy or has been mislabeled. To simulate this, we will change some of the labels of our dataset and add noise to some others. Intuitively, these anomalous data points should then have a lower value.\n", "\n", - "To evaluate this, let us first check the average value of the first 10 data points, as these will be the ones that we modify. Currently, these are the 10 data points with the highest semivalues:" + "To evaluate this, let us first check the average value of the first 10 data points, as these will be the ones that we modify. Currently, these are the 10 data points with the highest values:" ] }, { @@ -509,8 +499,8 @@ ], "source": [ "high_dvl = df.iloc[-10:].copy()\n", - "print(f\"Average value of first 10 data points: {high_dvl['data_value'].mean()}\")\n", - "print(f\"Exact values:\\n{high_dvl['data_value']}\")" + "print(f\"Average value of first 10 data points: {high_dvl['banzhaf_value'].mean()}\")\n", + "print(f\"Exact values:\\n{high_dvl['banzhaf_value']}\")" ] }, { @@ -593,12 +583,13 @@ " model=TorchCNNModel(),\n", " data=anomalous_dataset,\n", " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", + " cache_backend=MemcachedCacheBackend(MemcachedClientConfig())\n", ")\n", "anomalous_values = compute_banzhaf_semivalues(\n", " anomalous_utility, done=MaxChecks(max_checks), n_jobs=n_jobs, progress=True\n", ")\n", "anomalous_values.sort(key=\"value\")\n", - "anomalous_df = anomalous_values.to_dataframe(column=\"data_value\", use_names=True)" + "anomalous_df = anomalous_values.to_dataframe(column=\"banzhaf_value\", use_names=True)" ] }, { @@ -640,16 +631,16 @@ "\n", "\n", "plot_data = anomalous_df.loc[anomalous_indices].copy()\n", - "plot_data[\"original_data_value\"] = df.loc[anomalous_indices][\"data_value\"]\n", - "plot_data[\"original_data_value_stderr\"] = df.loc[anomalous_indices][\"data_value_stderr\"]\n", + "plot_data[\"original_banzhaf_value\"] = df.loc[anomalous_indices][\"banzhaf_value\"]\n", + "plot_data[\"original_banzhaf_value_stderr\"] = df.loc[anomalous_indices][\"banzhaf_value_stderr\"]\n", "plot_data.index = plot_data.index.map(str)\n", "\n", "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", - "yerr = norm.ppf(1 - 0.05 / 2) * plot_data[\"data_value_stderr\"]\n", - "original_yerr = norm.ppf(1 - 0.05 / 2) * plot_data[\"original_data_value_stderr\"]\n", + "yerr = norm.ppf(1 - 0.05 / 2) * plot_data[\"banzhaf_value_stderr\"]\n", + "original_yerr = norm.ppf(1 - 0.05 / 2) * plot_data[\"original_banzhaf_value_stderr\"]\n", "ax.errorbar(\n", " x=plot_data.index,\n", - " y=plot_data[\"data_value\"],\n", + " y=plot_data[\"banzhaf_value\"],\n", " yerr=yerr,\n", " fmt=\"o\",\n", " capsize=6,\n", @@ -658,7 +649,7 @@ ")\n", "ax.errorbar(\n", " x=plot_data.index,\n", - " y=plot_data[\"original_data_value\"],\n", + " y=plot_data[\"original_banzhaf_value\"],\n", " yerr=original_yerr,\n", " fmt=\"o\",\n", " capsize=6,\n", @@ -677,8 +668,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As can be seen in this figure, the valuation of the data points has decreased significantly by adding noise or falsifying their labels.\n", - "This shows the potential of using Banzhaf values or other data valuation methods to detect mislabeled data points or noisy input data." + "As can be seen in this figure, the valuation of the data points has decreased significantly by adding noise or falsifying their labels. This shows the potential of using Banzhaf values or other data valuation methods to detect mislabeled data points or noisy input data." ] }, { @@ -705,10 +695,10 @@ ], "source": [ "print(\n", - " f\"Average value of original data points: {plot_data['original_data_value'].mean()}\"\n", + " f\"Average value of original data points: {plot_data['original_banzhaf_value'].mean()}\"\n", ")\n", "print(\n", - " f\"Average value of modified, anomalous data points: {plot_data['data_value'].mean()}\"\n", + " f\"Average value of modified, anomalous data points: {plot_data['banzhaf_value'].mean()}\"\n", ")\n", "print(\n", " \"For reference, these are the average data values of all data points used for training (anomalous):\"\n", @@ -724,11 +714,35 @@ "source": [ "### Maximum Sample Reuse Banzhaf\n", "\n", - "Now, we want to use a method called Maximum Sample Reuse (MSR) which reuses samples for updating the Banzhaf values.\n", - "The method is introduced by Wang et al. in the paper *Data Banzhaf: A Robust Data Valuation Framework for Machine Learning*.\n", - "It promises a higher sample efficiency by using a principle called Maximum Sample Reuse for sampling and updating semivalues." + "Despite the previous results already being useful, we had to retrain the model a number of times and yet the variance of the value estimates was high. This has consequences for the stability of the top-k ranking of points, which decreases the applicability of the method. We now introduce a different sampling method called Maximum Sample Reuse (MSR) which reuses every sample for updating the Banzhaf values. The method was introduced by the authors of Data-Banzhaf and is much more sample-efficient, as we will show.\n", + "\n", + "We next construct a new utility. Note how this time we don't use a cache: the chance of hitting twice the same subset of the training set is low enough that one can dispense with it (nevertheless it can still be useful, e.g. when running many experiments)." ] }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "utility = Utility(\n", + " model=TorchCNNModel(),\n", + " data=dataset,\n", + " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", + " #cache_backend=MemcachedCacheBackend(MemcachedClientConfig())\n", + ")" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Computing the values is the same, but we now use a better stopping criterion. Instead of fixing the number of utility evaluations with [MaxChecks](../../api/pydvl/value/stopping/#pydvl.value.stopping.MaxChecks), we use [RankStability](../../api/pydvl/value/stopping/#pydvl.value.stopping.RankStability) to stop when the change in Spearman correlation between the ranking of two successive iterations is below a threshold. " + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", "execution_count": 17, @@ -747,12 +761,6 @@ } ], "source": [ - "# Compute MSR Banzhaf semivalue\n", - "utility = Utility(\n", - " model=TorchCNNModel(),\n", - " data=dataset,\n", - " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", - ")\n", "values = compute_msr_banzhaf_semivalues(\n", " utility,\n", " done=RankStability(0.0001),\n", @@ -760,9 +768,18 @@ " progress=True,\n", ")\n", "values.sort(key=\"value\")\n", - "msr_df = values.to_dataframe(column=\"data_value\", use_names=True)" + "msr_df = values.to_dataframe(column=\"banzhaf_value\", use_names=True)" ] }, + { + "cell_type": "markdown", + "source": [ + "Inspection of the values reveals (generally) much lower variances. Notice the number of updates to each value as well." + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", "execution_count": 18, @@ -907,9 +924,9 @@ "source": [ "### Compare convergence speed of Banzhaf and MSR Banzhaf Values\n", "\n", - "While the conventional Banzhaf values algorithm evaluates the utility twice to do one update of the Banzhaf values, the Maximum Samples Reuse (MSR) algorithm promises higher sample efficiency because it updates multiple samples per one evaluation of the utility. This part of the notebook takes a look at the convergence speed of the algorithms compared with each other. \n", + "Conventional margin-based samplers produce require evaluating the utility twice to do one update of the value, and permutation samplers do instead $n+1$ evaluations for $n$ updates. Maximum Sample Reuse (MSR) updates instead all indices in every sample that the utility evaluates. We compare the convergence rates of these methods.\n", "\n", - "To analyze this, we will compute the semivalues using different samplers and use a high number of iterations to make sure that the values are converged." + "In order to do so, we will compute the semi-values using different samplers and use a high number of iterations to make sure that the values have converged." ] }, { @@ -934,15 +951,15 @@ "source": [ "from sklearn.linear_model import SGDClassifier\n", "\n", - "if not is_CI:\n", + "if is_CI:\n", " utility = Utility(\n", - " model=TorchCNNModel(),\n", + " model=SGDClassifier(max_iter=2),\n", " data=dataset,\n", " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", " )\n", "else:\n", " utility = Utility(\n", - " model=SGDClassifier(max_iter=2),\n", + " model=TorchCNNModel(),\n", " data=dataset,\n", " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", " )" @@ -955,22 +972,22 @@ "outputs": [], "source": [ "def get_semivalues_and_history(\n", - " sampler_t, num_checks=max_checks, num_jobs=n_jobs, progress=True\n", + " sampler_t, max_checks=max_checks, n_jobs=n_jobs, progress=True\n", "):\n", - " _history = HistoryDeviation(n_steps=num_checks, rtol=1e-9)\n", + " _history = HistoryDeviation(n_steps=max_checks, rtol=1e-9)\n", " if sampler_t == MSRSampler:\n", " _values = compute_msr_banzhaf_semivalues(\n", " utility,\n", " sampler_t=sampler_t,\n", - " done=MaxChecks(num_checks + 2) | _history,\n", - " n_jobs=num_jobs,\n", + " done=MaxChecks(max_checks + 2) | _history,\n", + " n_jobs=n_jobs,\n", " progress=progress,\n", " )\n", " else:\n", " _values = compute_banzhaf_semivalues(\n", " utility,\n", - " done=MaxChecks(num_checks + 2) | _history,\n", - " n_jobs=num_jobs,\n", + " done=MaxChecks(max_checks + 2) | _history,\n", + " n_jobs=n_jobs,\n", " progress=progress,\n", " )\n", " return _history, _values" @@ -1094,8 +1111,6 @@ ], "source": [ "# Compare convergence speed of both methods\n", - "import numpy as np\n", - "\n", "names = [\"Permutation\", \"MSR\", \"Uniform\", \"Antithetic\", \"RandomHierarchical\"]\n", "all_values = [\n", " history_permutation._memory,\n", @@ -1139,18 +1154,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The plot above visualizes the convergence speed of different samplers used for Banzhaf semivalue calculation. \n", - "It shows the average magnitude of how much the semivalues are updated in every step of the algorithm. \n", + "The plot above visualizes the convergence speed of different samplers used for Banzhaf semivalue calculation. /It shows the average magnitude of how much the semivalues are updated in every step of the algorithm. \n", "\n", - "As you can see, **MSR Banzhaf** converges much faster. \n", - "After 1000 iterations (subsets tried), Monte Carlo Banzhaf has evaluated the marginal function about 5 times per data point (we are using 200 data points). \n", - "For maximum sample reuse, the semivalue of each data point was updated 1000 times. Due to this, the values converge much quicker, which is one of the advantages of MSR sampling. \n", + "As you can see, **MSR Banzhaf** stabilizes much faster. After 1000 iterations (subsets sampled and evaluated with the utility), Permutation Monte Carlo Banzhaf has evaluated the marginal function about 5 times per data point (we are using 200 data points). For MSR, the semivalue of each data point was updated 1000 times. Due to this, the values converge much faster wrt. the number of utility evaluations, which is the key advantage of MSR sampling. \n", "\n", - "MSR sampling does come at a cost, however, which is that the updates to the semivalues are more noisy than in other methods. \n", - "We will analyze the impact of this tradeoff in the next sections. \n", - "First, let us analyze how similar all the computed semivalues are. They are all Banzhaf values, so in a perfect world, all samplers should result in the exact same semivalues. However, due to randomness in the utility (it is a neural network) and randomness in the samplers, the resulting values are likely never exactly the same. \n", - "Another quality measure is that a good sampler would lead to very consistent values, a bad one to less consistent values. \n", - "Let us analyze how similar the samplers are first, then look at consistency." + "MSR sampling does come at a cost, however, which is that the updates to the semivalues are more noisy than in other methods. We will analyze the impact of this tradeoff in the next sections. First, let us look at how similar all the computed semivalues are. They are all Banzhaf values, so in a perfect world, all samplers should result in the exact same semivalues. However, due to randomness in the utility (recall that we use a neural network) and randomness in the samplers, the resulting values are likely never exactly the same. Another quality measure is that a good sampler would lead to very consistent values, a bad one to less consistent values. Let us first examine how similar the results are, then we'll look at consistency." ] }, { @@ -1360,7 +1368,7 @@ " for check_index, max_check in enumerate(max_checks):\n", " for retry in range(num_retries):\n", " _, vals = get_semivalues_and_history(\n", - " sampler, num_checks=max_check, progress=False\n", + " sampler, max_checks=max_check, progress=False\n", " )\n", " results[check_index][sampler_index].append(vals)\n", " pbar.n = (\n", diff --git a/notebooks/support/banzhaf.py b/notebooks/support/banzhaf.py index 35f1ff9fc..75b59765d 100644 --- a/notebooks/support/banzhaf.py +++ b/notebooks/support/banzhaf.py @@ -2,6 +2,10 @@ from sklearn.datasets import load_digits from sklearn.model_selection import train_test_split +from torch import nn, optim +from torch.utils.data import TensorDataset, DataLoader +from numpy.typing import NDArray +from pydvl.utils.types import SupervisedModel def load_digits_dataset( @@ -40,3 +44,64 @@ def load_digits_dataset( x_val, y_val = None, None return ((x_train, y_train), (x_val, y_val), (x_test, y_test)) + + +class TorchCNNModel(SupervisedModel): + def __init__( + self, + lr: float, + epochs: int, + batch_size: int, + device: str, + ): + self.lr = lr + self.batch_size = batch_size + self.model = nn.Sequential( + nn.Conv2d( + out_channels=8, in_channels=1, kernel_size=(3, 3), padding="same" + ), + nn.Conv2d( + out_channels=4, in_channels=8, kernel_size=(3, 3), padding="same" + ), + nn.MaxPool2d(kernel_size=2), + nn.Flatten(), + nn.Linear(in_features=64, out_features=32), + nn.Linear(in_features=32, out_features=10), + nn.Softmax(dim=1), + ) + self.loss = nn.CrossEntropyLoss() + self.optimizer = optim.Adam(self.model.parameters(), lr=lr) + self.epochs = epochs + self.model.to(device) + + def fit(self, x: NDArray, y: NDArray) -> None: + torch_dataset = TensorDataset( + torch.tensor( + np.reshape(x, (x.shape[0], 1, 8, 8)), dtype=torch.float, device=device + ), + torch.tensor(y, device=device), + ) + torch_dataloader = DataLoader(torch_dataset, batch_size=self.batch_size) + for epoch in range(self.epochs): + for features, labels in torch_dataloader: + pred = self.model(features) + loss = self.loss(pred, labels) + loss.backward() + self.optimizer.step() + + def predict(self, x: NDArray) -> NDArray: + pred = self.model( + torch.tensor( + np.reshape(x, (x.shape[0], 1, 8, 8)), dtype=torch.float, device=device + ) + ) + pred = torch.argmax(pred, dim=1) + return pred.cpu().numpy() + + def score(self, x: NDArray, y: NDArray) -> float: + pred = self.predict(x) + acc = accuracy_score(pred, y) + return acc + + def get_params(self, deep: bool = False): + return {"lr": self.lr, "epochs": self.epochs} From 2a395ee880fc306f5d40c25c91b7cee7c1c5eed8 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Tue, 9 Apr 2024 00:37:37 +0200 Subject: [PATCH 32/42] Add number of updates to results dataframe --- src/pydvl/value/result.py | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index bd6a78d10..c239456a7 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -41,6 +41,7 @@ samples random values uniformly. """ + from __future__ import annotations import collections.abc @@ -357,16 +358,13 @@ def __getattr__(self, attr: str) -> Any: ) from e @overload - def __getitem__(self, key: int) -> ValueItem: - ... + def __getitem__(self, key: int) -> ValueItem: ... @overload - def __getitem__(self, key: slice) -> List[ValueItem]: - ... + def __getitem__(self, key: slice) -> List[ValueItem]: ... @overload - def __getitem__(self, key: Iterable[int]) -> List[ValueItem]: - ... + def __getitem__(self, key: Iterable[int]) -> List[ValueItem]: ... def __getitem__( self, key: Union[slice, Iterable[int], int] @@ -392,16 +390,13 @@ def __getitem__( raise TypeError("Indices must be integers, iterable or slices") @overload - def __setitem__(self, key: int, value: ValueItem) -> None: - ... + def __setitem__(self, key: int, value: ValueItem) -> None: ... @overload - def __setitem__(self, key: slice, value: ValueItem) -> None: - ... + def __setitem__(self, key: slice, value: ValueItem) -> None: ... @overload - def __setitem__(self, key: Iterable[int], value: ValueItem) -> None: - ... + def __setitem__(self, key: Iterable[int], value: ValueItem) -> None: ... def __setitem__( self, key: Union[slice, Iterable[int], int], value: ValueItem @@ -676,12 +671,15 @@ def to_dataframe( column = column or self._algorithm df = pd.DataFrame( self._values[self._sort_positions], - index=self._names[self._sort_positions] - if use_names - else self._indices[self._sort_positions], + index=( + self._names[self._sort_positions] + if use_names + else self._indices[self._sort_positions] + ), columns=[column], ) df[column + "_stderr"] = self.stderr[self._sort_positions] + df[column + "_updates"] = self.counts[self._sort_positions] return df @classmethod From cb50644776bbba4c77247ea6e6f952f0a521ebad Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 11 Apr 2024 20:00:43 +0200 Subject: [PATCH 33/42] Add notebook to gallery --- docs/examples/img/msr_banzhaf_digits.png | 3 +++ docs/examples/index.md | 9 +++++++++ docs/getting-started/glossary.md | 9 +++++++++ docs_includes/abbreviations.md | 1 + 4 files changed, 22 insertions(+) create mode 100644 docs/examples/img/msr_banzhaf_digits.png diff --git a/docs/examples/img/msr_banzhaf_digits.png b/docs/examples/img/msr_banzhaf_digits.png new file mode 100644 index 000000000..a21479b9f --- /dev/null +++ b/docs/examples/img/msr_banzhaf_digits.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:73bcfab3eadb3935722e78cc6b556a67cde50125cb7f53461ee5f468d6cb5b6d +size 21291 diff --git a/docs/examples/index.md b/docs/examples/index.md index 3ab36c0a2..9384ea4d4 100644 --- a/docs/examples/index.md +++ b/docs/examples/index.md @@ -53,6 +53,15 @@ alias: [![](img/data_oob.png)](data_oob/) +- [__Faster Banzhaf values__](msr_banzhaf_digits/) + + --- + + Using Banzhaf values to estimate the value of data points in MNIST, and + evaluating convergence speed of MSR. + + [![](img/msr_banzhaf_digits.png)](msr_banzhaf_digits/) + diff --git a/docs/getting-started/glossary.md b/docs/getting-started/glossary.md index 56ce7786f..ecb1eaf2c 100644 --- a/docs/getting-started/glossary.md +++ b/docs/getting-started/glossary.md @@ -147,6 +147,15 @@ performance when that point is removed from the training set. * [Implementation][pydvl.value.loo.loo.compute_loo] * [Documentation][leave-one-out-values] +### Maximum Sample Reuse + +MSR is a sampling method for data valuation that updates the value of every +data point in one sample. This method can achieve much faster convergence. +Introduced by [@wang_data_2023] + +* [Implementation][pydvl.value.sampler.MSRSampler] + + ### Monte Carlo Least Core MCLC is a variation of the Least Core that uses a reduced amount of diff --git a/docs_includes/abbreviations.md b/docs_includes/abbreviations.md index a584b73d8..9465106f3 100644 --- a/docs_includes/abbreviations.md +++ b/docs_includes/abbreviations.md @@ -19,6 +19,7 @@ *[MLRC]: Machine Learning Reproducibility Challenge *[ML]: Machine Learning *[MSE]: Mean Squared Error +*[MSR]: Maximum Sample Reuse *[NLRA]: Nyström Low-Rank Approximation *[OOB]: Out-of-Bag *[PCA]: Principal Component Analysis From 23532ce378b4aa4d8f5fd8bf7ec8ed7040326c6b Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 11 Apr 2024 20:01:42 +0200 Subject: [PATCH 34/42] Fix imports and other minor stuff --- notebooks/msr_banzhaf_digits.ipynb | 747 +++++------------------------ notebooks/support/banzhaf.py | 43 +- src/pydvl/reporting/plots.py | 5 +- 3 files changed, 156 insertions(+), 639 deletions(-) diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb index 1e37ce9a3..8e31e7412 100644 --- a/notebooks/msr_banzhaf_digits.ipynb +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -21,8 +21,6 @@ "source": [ "## Setup\n", "\n", - "We begin by importing the main libraries and setting some defaults.\n", - "\n", "
\n", "\n", "If you are reading this in the documentation, some boilerplate (including most plotting code) has been omitted for convenience.\n", @@ -32,36 +30,25 @@ }, { "cell_type": "code", - "execution_count": 1, "metadata": { "tags": [ "hide" - ], - "ExecuteTime": { - "end_time": "2024-04-08T14:22:52.254834Z", - "start_time": "2024-04-08T14:22:52.233863Z" - } + ] }, - "outputs": [], "source": [ "%load_ext autoreload" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 2, "metadata": { "tags": [ "hide" - ], - "ExecuteTime": { - "end_time": "2024-04-08T14:22:52.920403Z", - "start_time": "2024-04-08T14:22:52.256226Z" - } + ] }, - "outputs": [], "source": [ - "%autoreload\n", "%matplotlib inline\n", "\n", "import os\n", @@ -82,7 +69,9 @@ "random_state = 24\n", "n_jobs = 16\n", "random.seed(random_state)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -94,29 +83,15 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2024-04-08T14:22:55.166766Z", - "start_time": "2024-04-08T14:22:53.929035Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/miguel/devel/tfl/pydvl/src/pydvl/parallel/config.py:31: FutureWarning: The `ParallelConfig` class was deprecated in v0.9.0 and will be removed in v0.10.0\n", - " warnings.warn(\n" - ] - } - ], + "metadata": {}, "source": [ "%autoreload\n", "from pydvl.reporting.plots import plot_shapley\n", "from support.banzhaf import load_digits_dataset\n", "from pydvl.value import *" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -129,45 +104,23 @@ }, { "cell_type": "code", - "execution_count": 4, "metadata": { "editable": true, "slideshow": { "slide_type": "" }, - "tags": [], - "ExecuteTime": { - "end_time": "2024-04-08T14:22:58.625795Z", - "start_time": "2024-04-08T14:22:58.601936Z" - } + "tags": [] }, - "outputs": [ - { - "ename": "RuntimeError", - "evalue": "PyTorch is required in order to load the Digits Dataset", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mModuleNotFoundError\u001B[0m Traceback (most recent call last)", - "File \u001B[0;32m~/devel/tfl/pydvl/notebooks/support/banzhaf.py:21\u001B[0m, in \u001B[0;36mload_digits_dataset\u001B[0;34m(test_size, val_size, random_state)\u001B[0m\n\u001B[1;32m 20\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m---> 21\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mtorch\u001B[39;00m\n\u001B[1;32m 22\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mImportError\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n", - "\u001B[0;31mModuleNotFoundError\u001B[0m: No module named 'torch'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001B[0;31mRuntimeError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[4], line 1\u001B[0m\n\u001B[0;32m----> 1\u001B[0m training_data, _, test_data \u001B[38;5;241m=\u001B[39m \u001B[43mload_digits_dataset\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 2\u001B[0m \u001B[43m \u001B[49m\u001B[43mtest_size\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;241;43m0.3\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrandom_state\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mrandom_state\u001B[49m\n\u001B[1;32m 3\u001B[0m \u001B[43m)\u001B[49m\n", - "File \u001B[0;32m~/devel/tfl/pydvl/notebooks/support/banzhaf.py:23\u001B[0m, in \u001B[0;36mload_digits_dataset\u001B[0;34m(test_size, val_size, random_state)\u001B[0m\n\u001B[1;32m 21\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mtorch\u001B[39;00m\n\u001B[1;32m 22\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mImportError\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[0;32m---> 23\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mRuntimeError\u001B[39;00m(\n\u001B[1;32m 24\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mPyTorch is required in order to load the Digits Dataset\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 25\u001B[0m ) \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01me\u001B[39;00m\n\u001B[1;32m 27\u001B[0m digits_bunch \u001B[38;5;241m=\u001B[39m load_digits(as_frame\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m)\n\u001B[1;32m 28\u001B[0m x, x_test, y, y_test \u001B[38;5;241m=\u001B[39m train_test_split(\n\u001B[1;32m 29\u001B[0m digits_bunch\u001B[38;5;241m.\u001B[39mdata\u001B[38;5;241m.\u001B[39mvalues \u001B[38;5;241m/\u001B[39m \u001B[38;5;241m16.0\u001B[39m,\n\u001B[1;32m 30\u001B[0m digits_bunch\u001B[38;5;241m.\u001B[39mtarget\u001B[38;5;241m.\u001B[39mvalues,\n\u001B[1;32m 31\u001B[0m train_size\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m1\u001B[39m \u001B[38;5;241m-\u001B[39m test_size,\n\u001B[1;32m 32\u001B[0m random_state\u001B[38;5;241m=\u001B[39mrandom_state,\n\u001B[1;32m 33\u001B[0m )\n", - "\u001B[0;31mRuntimeError\u001B[0m: PyTorch is required in order to load the Digits Dataset" - ] - } - ], "source": [ "training_data, _, test_data = load_digits_dataset(\n", " test_size=0.3, random_state=random_state\n", ")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 5, "metadata": { "editable": true, "slideshow": { @@ -177,7 +130,6 @@ "hide" ] }, - "outputs": [], "source": [ "# In CI we only use a subset of the training set\n", "training_data = list(training_data)\n", @@ -189,26 +141,13 @@ " training_data[0] = training_data[0][:200]\n", " training_data[1] = training_data[1][:200]\n", " max_checks = 1000" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 6, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "# Visualize some of the data\n", "fig, axes = plt.subplots(2, 2, figsize=(4, 4))\n", @@ -219,7 +158,9 @@ "plt.suptitle(\"Example images from the dataset\")\n", "plt.tight_layout()\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -230,12 +171,12 @@ }, { "cell_type": "code", - "execution_count": 7, "metadata": {}, - "outputs": [], "source": [ "dataset = Dataset(*training_data, *test_data)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -250,18 +191,7 @@ }, { "cell_type": "code", - "execution_count": 8, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train Accuracy: 0.665\n", - "Test Accuracy: 0.619\n" - ] - } - ], "source": [ "import torch\n", "from support.banzhaf import TorchCNNModel\n", @@ -272,7 +202,9 @@ "\n", "print(f\"Train Accuracy: {model.score(x=training_data[0], y=training_data[1]):.3f}\")\n", "print(f\"Test Accuracy: {model.score(x=test_data[0], y=test_data[1]):.3f}\")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -289,26 +221,13 @@ }, { "cell_type": "code", - "execution_count": 9, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - " 0%| | 0/100 [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
data_valuedata_value_stderr
66-1.0485240.029862
152-0.9945730.008960
64-0.7608250.018543
3-0.7181650.642347
14-0.7075690.323538
\n", - "
" - ], - "text/plain": [ - " data_value data_value_stderr\n", - "66 -1.048524 0.029862\n", - "152 -0.994573 0.008960\n", - "64 -0.760825 0.018543\n", - "3 -0.718165 0.642347\n", - "14 -0.707569 0.323538" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "df.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -414,7 +264,6 @@ }, { "cell_type": "code", - "execution_count": 11, "metadata": { "editable": true, "slideshow": { @@ -425,20 +274,6 @@ "invertible-output" ] }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "low_dvl = df.iloc[:30].copy()\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -448,9 +283,12 @@ " title=\"Images with low values\",\n", " xlabel=\"Image\",\n", " ylabel=\"Banzhaf value\",\n", + " prefix=\"banzhaf_value\"\n", ")\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -465,7 +303,6 @@ }, { "cell_type": "code", - "execution_count": 12, "metadata": { "editable": true, "slideshow": { @@ -476,32 +313,13 @@ "invertible-output" ] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Average value of first 10 data points: 0.6300257540520159\n", - "Exact values:\n", - "39 0.392304\n", - "167 0.461181\n", - "33 0.468827\n", - "169 0.519828\n", - "135 0.551593\n", - "19 0.594768\n", - "51 0.636773\n", - "140 0.741426\n", - "71 0.880786\n", - "121 1.052771\n", - "Name: data_value, dtype: float64\n" - ] - } - ], "source": [ "high_dvl = df.iloc[-10:].copy()\n", "print(f\"Average value of first 10 data points: {high_dvl['banzhaf_value'].mean()}\")\n", "print(f\"Exact values:\\n{high_dvl['banzhaf_value']}\")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -512,22 +330,7 @@ }, { "cell_type": "code", - "execution_count": 13, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "x_train_anomalous = training_data[0].copy()\n", "y_train_anomalous = training_data[1].copy()\n", @@ -553,24 +356,13 @@ "plt.suptitle(\"Original and noisy versions of images 6-10\")\n", "plt.tight_layout()\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 14, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - " 0%| | 0/100 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "from scipy.stats import norm\n", "\n", @@ -662,7 +441,9 @@ "plt.legend()\n", "plt.xticks(rotation=60)\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -673,26 +454,7 @@ }, { "cell_type": "code", - "execution_count": 16, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Average value of original data points: 0.6300257540520159\n", - "Average value of modified, anomalous data points: 0.07210118735126189\n", - "For reference, these are the average data values of all data points used for training (anomalous):\n", - "data_value 0.022450\n", - "data_value_stderr 0.083306\n", - "dtype: float64\n", - "These are the average data values of all points (original data):\n", - "data_value -0.016296\n", - "data_value_stderr 0.118257\n", - "dtype: float64\n" - ] - } - ], "source": [ "print(\n", " f\"Average value of original data points: {plot_data['original_banzhaf_value'].mean()}\"\n", @@ -706,7 +468,9 @@ "print(anomalous_df.mean())\n", "print(\"These are the average data values of all points (original data):\")\n", "print(df.mean())" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -721,18 +485,19 @@ }, { "cell_type": "code", - "outputs": [], "source": [ "utility = Utility(\n", " model=TorchCNNModel(),\n", " data=dataset,\n", " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", - " #cache_backend=MemcachedCacheBackend(MemcachedClientConfig())\n", + " cache_backend=MemcachedCacheBackend(MemcachedClientConfig())\n", ")" ], "metadata": { "collapsed": false - } + }, + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -745,21 +510,7 @@ }, { "cell_type": "code", - "execution_count": 17, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/100 [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
data_valuedata_value_stderr
136-0.0955750.049190
142-0.0872620.043481
187-0.0853640.046185
22-0.0812510.039468
5-0.0803460.041551
\n", - "" - ], - "text/plain": [ - " data_value data_value_stderr\n", - "136 -0.095575 0.049190\n", - "142 -0.087262 0.043481\n", - "187 -0.085364 0.046185\n", - "22 -0.081251 0.039468\n", - "5 -0.080346 0.041551" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "msr_df.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 19, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "high_dvl = df.iloc[-30:]\n", "high_dvl.index = high_dvl.index.map(str)\n", @@ -884,28 +553,16 @@ " title=\"Images with high values\",\n", " xlabel=\"Image\",\n", " ylabel=\"Banzhaf Value\",\n", + " prefix=\"banzhaf_value\"\n", ")\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 20, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "low_dvl = df.iloc[:30]\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -914,9 +571,12 @@ " title=\"Images with low values\",\n", " xlabel=\"Image\",\n", " ylabel=\"Banzhaf value\",\n", + " prefix=\"banzhaf_value\"\n", ")\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -931,9 +591,7 @@ }, { "cell_type": "code", - "execution_count": 21, "metadata": {}, - "outputs": [], "source": [ "if is_CI:\n", " max_checks = 1\n", @@ -941,13 +599,13 @@ "else:\n", " max_checks = 10000\n", " moving_avg = 200" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 22, "metadata": {}, - "outputs": [], "source": [ "from sklearn.linear_model import SGDClassifier\n", "\n", @@ -963,152 +621,83 @@ " data=dataset,\n", " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", " )" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 23, "metadata": {}, - "outputs": [], "source": [ "def get_semivalues_and_history(\n", " sampler_t, max_checks=max_checks, n_jobs=n_jobs, progress=True\n", "):\n", " _history = HistoryDeviation(n_steps=max_checks, rtol=1e-9)\n", - " if sampler_t == MSRSampler:\n", - " _values = compute_msr_banzhaf_semivalues(\n", - " utility,\n", - " sampler_t=sampler_t,\n", - " done=MaxChecks(max_checks + 2) | _history,\n", - " n_jobs=n_jobs,\n", - " progress=progress,\n", - " )\n", - " else:\n", - " _values = compute_banzhaf_semivalues(\n", - " utility,\n", - " done=MaxChecks(max_checks + 2) | _history,\n", - " n_jobs=n_jobs,\n", - " progress=progress,\n", - " )\n", + " _values = compute_msr_banzhaf_semivalues(\n", + " utility,\n", + " sampler_t=sampler_t,\n", + " done=MaxChecks(max_checks + 2) | _history,\n", + " n_jobs=n_jobs,\n", + " progress=progress,\n", + " )\n", " return _history, _values" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 24, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", - " 0%| | 0/100 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "# Compare convergence speed of both methods\n", "names = [\"Permutation\", \"MSR\", \"Uniform\", \"Antithetic\", \"RandomHierarchical\"]\n", @@ -1148,7 +737,9 @@ "plt.ylim(1e-5, 1)\n", "plt.legend()\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1170,9 +761,7 @@ }, { "cell_type": "code", - "execution_count": 30, "metadata": {}, - "outputs": [], "source": [ "names = [\"Permutation\", \"MSR\", \"Uniform\", \"Antithetic\", \"RandomHierarchical\"]\n", "values = [\n", @@ -1198,26 +787,13 @@ " low_consistency[sampler1_id, sampler2_id] = len(\n", " lower_20_1.intersection(lower_20_2)\n", " )" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 31, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "fix, axes = plt.subplots(1, 2, figsize=(10, 5))\n", "axes[0].matshow(top_consistency, vmin=0, vmax=twenty_percent)\n", @@ -1237,7 +813,9 @@ "plt.suptitle(\"Overlapping high and low value points between samplers\")\n", "plt.tight_layout()\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1252,17 +830,7 @@ }, { "cell_type": "code", - "execution_count": 36, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total number of top 20 points that all samplers have in common: 1\n" - ] - } - ], "source": [ "all_in_common = set(permutation_values.indices.tolist())\n", "for sampler_id, sampler_values in enumerate(values):\n", @@ -1272,7 +840,9 @@ "print(\n", " f\"Total number of top 20 points that all samplers have in common: {len(all_in_common)}\"\n", ")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1286,69 +856,19 @@ }, { "cell_type": "code", - "execution_count": 32, "metadata": {}, - "outputs": [], "source": [ "max_checks = [1000, 2000, 3000] if not is_CI else [1]\n", "num_retries = 3 if not is_CI else 1\n", "num_samplers = 5\n", "twenty_percent = training_data[0].shape[0] // 5" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 33, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/45 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "# Plot results\n", "\n", @@ -1453,7 +960,9 @@ "fig.suptitle(f\"Evaluation of consistency of samplers (Max value: {twenty_percent})\")\n", "fig.tight_layout()\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", diff --git a/notebooks/support/banzhaf.py b/notebooks/support/banzhaf.py index 75b59765d..13ccd5e7f 100644 --- a/notebooks/support/banzhaf.py +++ b/notebooks/support/banzhaf.py @@ -1,12 +1,20 @@ -from typing import Optional +import numpy as np +from numpy.typing import NDArray from sklearn.datasets import load_digits +from sklearn.metrics import accuracy_score from sklearn.model_selection import train_test_split -from torch import nn, optim -from torch.utils.data import TensorDataset, DataLoader -from numpy.typing import NDArray +from typing import Optional + from pydvl.utils.types import SupervisedModel +try: + import torch + from torch import nn, optim + from torch.utils.data import TensorDataset, DataLoader +except ImportError as e: + raise RuntimeError("PyTorch is required to run the Banzhaf MSR notebook") from e + def load_digits_dataset( test_size: float, val_size: float = 0.0, random_state: Optional[int] = None @@ -21,12 +29,6 @@ def load_digits_dataset( target values in the form of matrices of shape (N,8,8) the first and (N,) the second. """ - try: - import torch - except ImportError as e: - raise RuntimeError( - "PyTorch is required in order to load the Digits Dataset" - ) from e digits_bunch = load_digits(as_frame=True) x, x_test, y, y_test = train_test_split( @@ -49,13 +51,15 @@ def load_digits_dataset( class TorchCNNModel(SupervisedModel): def __init__( self, - lr: float, - epochs: int, - batch_size: int, - device: str, + lr: float = 0.001, + epochs: int = 40, + batch_size: int = 32, + device: str = "cuda" if torch.cuda.is_available() else "cpu", ): self.lr = lr self.batch_size = batch_size + self.epochs = epochs + self.device = device self.model = nn.Sequential( nn.Conv2d( out_channels=8, in_channels=1, kernel_size=(3, 3), padding="same" @@ -71,15 +75,16 @@ def __init__( ) self.loss = nn.CrossEntropyLoss() self.optimizer = optim.Adam(self.model.parameters(), lr=lr) - self.epochs = epochs self.model.to(device) def fit(self, x: NDArray, y: NDArray) -> None: torch_dataset = TensorDataset( torch.tensor( - np.reshape(x, (x.shape[0], 1, 8, 8)), dtype=torch.float, device=device + np.reshape(x, (x.shape[0], 1, 8, 8)), + dtype=torch.float, + device=self.device, ), - torch.tensor(y, device=device), + torch.tensor(y, device=self.device), ) torch_dataloader = DataLoader(torch_dataset, batch_size=self.batch_size) for epoch in range(self.epochs): @@ -92,7 +97,9 @@ def fit(self, x: NDArray, y: NDArray) -> None: def predict(self, x: NDArray) -> NDArray: pred = self.model( torch.tensor( - np.reshape(x, (x.shape[0], 1, 8, 8)), dtype=torch.float, device=device + np.reshape(x, (x.shape[0], 1, 8, 8)), + dtype=torch.float, + device=self.device, ) ) pred = torch.argmax(pred, dim=1) diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index 7c0f19b73..8f72ccf27 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -240,6 +240,7 @@ def plot_shapley( title: Optional[str] = None, xlabel: Optional[str] = None, ylabel: Optional[str] = None, + prefix: Optional[str] = "data_value", ) -> plt.Axes: r"""Plots the shapley values, as returned from [compute_shapley_values][pydvl.value.shapley.common.compute_shapley_values], @@ -260,9 +261,9 @@ def plot_shapley( if ax is None: _, ax = plt.subplots() - yerr = norm.ppf(1 - level / 2) * df["data_value_stderr"] + yerr = norm.ppf(1 - level / 2) * df[f"{prefix}_stderr"] - ax.errorbar(x=df.index, y=df["data_value"], yerr=yerr, fmt="o", capsize=6) + ax.errorbar(x=df.index, y=df[prefix], yerr=yerr, fmt="o", capsize=6) ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) ax.set_title(title) From fdad917386c15e4a8cb28ab94c9858295d417376 Mon Sep 17 00:00:00 2001 From: jakob1111996 Date: Fri, 12 Apr 2024 14:35:13 +0200 Subject: [PATCH 35/42] run notebook complete --- notebooks/msr_banzhaf_digits.ipynb | 681 +++++++++++++++++++++++------ 1 file changed, 546 insertions(+), 135 deletions(-) diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb index 8e31e7412..8dff51298 100644 --- a/notebooks/msr_banzhaf_digits.ipynb +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -30,24 +30,26 @@ }, { "cell_type": "code", + "execution_count": 1, "metadata": { "tags": [ "hide" ] }, + "outputs": [], "source": [ "%load_ext autoreload" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 2, "metadata": { "tags": [ "hide" ] }, + "outputs": [], "source": [ "%matplotlib inline\n", "\n", @@ -69,9 +71,7 @@ "random_state = 24\n", "n_jobs = 16\n", "random.seed(random_state)" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -83,15 +83,15 @@ }, { "cell_type": "code", + "execution_count": 3, "metadata": {}, + "outputs": [], "source": [ "%autoreload\n", "from pydvl.reporting.plots import plot_shapley\n", "from support.banzhaf import load_digits_dataset\n", "from pydvl.value import *" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -104,6 +104,7 @@ }, { "cell_type": "code", + "execution_count": 4, "metadata": { "editable": true, "slideshow": { @@ -111,16 +112,16 @@ }, "tags": [] }, + "outputs": [], "source": [ "training_data, _, test_data = load_digits_dataset(\n", " test_size=0.3, random_state=random_state\n", ")" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 5, "metadata": { "editable": true, "slideshow": { @@ -130,6 +131,7 @@ "hide" ] }, + "outputs": [], "source": [ "# In CI we only use a subset of the training set\n", "training_data = list(training_data)\n", @@ -141,13 +143,26 @@ " training_data[0] = training_data[0][:200]\n", " training_data[1] = training_data[1][:200]\n", " max_checks = 1000" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 6, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Visualize some of the data\n", "fig, axes = plt.subplots(2, 2, figsize=(4, 4))\n", @@ -158,9 +173,7 @@ "plt.suptitle(\"Example images from the dataset\")\n", "plt.tight_layout()\n", "plt.show()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -171,12 +184,12 @@ }, { "cell_type": "code", + "execution_count": 7, "metadata": {}, + "outputs": [], "source": [ "dataset = Dataset(*training_data, *test_data)" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -191,7 +204,18 @@ }, { "cell_type": "code", + "execution_count": 8, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Accuracy: 0.705\n", + "Test Accuracy: 0.630\n" + ] + } + ], "source": [ "import torch\n", "from support.banzhaf import TorchCNNModel\n", @@ -202,26 +226,32 @@ "\n", "print(f\"Train Accuracy: {model.score(x=training_data[0], y=training_data[1]):.3f}\")\n", "print(f\"Test Accuracy: {model.score(x=test_data[0], y=test_data[1]):.3f}\")" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "The final component is the scoring function. It can be anything like accuracy or $R^2$, and is set with a string from the [standard sklearn scoring methods](https://scikit-learn.org/stable/modules/model_evaluation.html). Please refer to that documentation on information on how to define your own scoring function.\n", "\n", "We group dataset, model and scoring function into an instance of [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility) and compute the Banzhaf semi-values. We take all defaults, and choose to stop computation using the [MaxChecks](../../api/pydvl/value/stopping/#pydvl.value.stopping.MaxChecks) stopping criterion, which terminates after a fixed number of calls to it. With the default `batch_size` of 1 this means that we will retrain the model.\n", "\n", "Note how we enable caching using memcached (assuming memcached runs with the default configuration for localhost). This is necessary in the current preliminary implementation of [permutation sampling](../../api/pydvl/value/sampler/#pydvl.value.sampler.PermutationSampler), which is the default for [compute_banzhaf_semivalues](../../api/pydvl/value/semivalues#pydvl.value.semivalues.compute_banzhaf_semivalues)." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", + "execution_count": 9, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████▉| 99.9/100 [01:01<00:00, 1.62%/s] \n" + ] + } + ], "source": [ "from pydvl.utils import MemcachedCacheBackend, MemcachedClientConfig\n", "\n", @@ -230,30 +260,105 @@ " model=model,\n", " data=dataset,\n", " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", - " cache_backend=MemcachedCacheBackend(MemcachedClientConfig())\n", + " cache_backend=MemcachedCacheBackend(MemcachedClientConfig()),\n", ")\n", "values = compute_banzhaf_semivalues(\n", " utility, done=MaxChecks(max_checks), n_jobs=n_jobs, progress=True\n", ")\n", "values.sort(key=\"value\")\n", "df = values.to_dataframe(column=\"banzhaf_value\", use_names=True)" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", "metadata": {}, - "source": ".The returned dataframe contains the mean and variance of the Monte Carlo estimates for the values:" + "source": [ + ".The returned dataframe contains the mean and variance of the Monte Carlo estimates for the values:" + ] }, { "cell_type": "code", + "execution_count": 10, "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
banzhaf_valuebanzhaf_value_stderrbanzhaf_value_updates
156-1.0979206.662418e-025
21-0.9254891.230752e-015
152-0.9133133.358054e-025
73-0.7788843.668419e-055
85-0.6444353.454322e-085
\n", + "
" + ], + "text/plain": [ + " banzhaf_value banzhaf_value_stderr banzhaf_value_updates\n", + "156 -1.097920 6.662418e-02 5\n", + "21 -0.925489 1.230752e-01 5\n", + "152 -0.913313 3.358054e-02 5\n", + "73 -0.778884 3.668419e-05 5\n", + "85 -0.644435 3.454322e-08 5" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "df.head()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -264,6 +369,7 @@ }, { "cell_type": "code", + "execution_count": 11, "metadata": { "editable": true, "slideshow": { @@ -274,6 +380,20 @@ "invertible-output" ] }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "low_dvl = df.iloc[:30].copy()\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -283,12 +403,10 @@ " title=\"Images with low values\",\n", " xlabel=\"Image\",\n", " ylabel=\"Banzhaf value\",\n", - " prefix=\"banzhaf_value\"\n", + " prefix=\"banzhaf_value\",\n", ")\n", "plt.show()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -303,6 +421,7 @@ }, { "cell_type": "code", + "execution_count": 12, "metadata": { "editable": true, "slideshow": { @@ -313,13 +432,32 @@ "invertible-output" ] }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average value of first 10 data points: 0.650003277874342\n", + "Exact values:\n", + "39 0.432836\n", + "45 0.455392\n", + "158 0.533221\n", + "144 0.571260\n", + "36 0.633091\n", + "161 0.697940\n", + "77 0.698507\n", + "28 0.752367\n", + "35 0.838752\n", + "175 0.886668\n", + "Name: banzhaf_value, dtype: float64\n" + ] + } + ], "source": [ "high_dvl = df.iloc[-10:].copy()\n", "print(f\"Average value of first 10 data points: {high_dvl['banzhaf_value'].mean()}\")\n", "print(f\"Exact values:\\n{high_dvl['banzhaf_value']}\")" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -330,7 +468,22 @@ }, { "cell_type": "code", + "execution_count": 13, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "x_train_anomalous = training_data[0].copy()\n", "y_train_anomalous = training_data[1].copy()\n", @@ -356,13 +509,21 @@ "plt.suptitle(\"Original and noisy versions of images 6-10\")\n", "plt.tight_layout()\n", "plt.show()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 14, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████▉| 99.9/100 [00:59<00:00, 1.69%/s] \n" + ] + } + ], "source": [ "anomalous_dataset = Dataset(\n", " x_train=x_train_anomalous,\n", @@ -375,16 +536,14 @@ " model=TorchCNNModel(),\n", " data=anomalous_dataset,\n", " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", - " cache_backend=MemcachedCacheBackend(MemcachedClientConfig())\n", + " cache_backend=MemcachedCacheBackend(MemcachedClientConfig()),\n", ")\n", "anomalous_values = compute_banzhaf_semivalues(\n", " anomalous_utility, done=MaxChecks(max_checks), n_jobs=n_jobs, progress=True\n", ")\n", "anomalous_values.sort(key=\"value\")\n", "anomalous_df = anomalous_values.to_dataframe(column=\"banzhaf_value\", use_names=True)" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -395,6 +554,7 @@ }, { "cell_type": "code", + "execution_count": 15, "metadata": { "editable": true, "slideshow": { @@ -405,13 +565,29 @@ "invertible-output" ] }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "from scipy.stats import norm\n", "\n", "\n", "plot_data = anomalous_df.loc[anomalous_indices].copy()\n", "plot_data[\"original_banzhaf_value\"] = df.loc[anomalous_indices][\"banzhaf_value\"]\n", - "plot_data[\"original_banzhaf_value_stderr\"] = df.loc[anomalous_indices][\"banzhaf_value_stderr\"]\n", + "plot_data[\"original_banzhaf_value_stderr\"] = df.loc[anomalous_indices][\n", + " \"banzhaf_value_stderr\"\n", + "]\n", "plot_data.index = plot_data.index.map(str)\n", "\n", "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", @@ -441,9 +617,7 @@ "plt.legend()\n", "plt.xticks(rotation=60)\n", "plt.show()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -454,7 +628,28 @@ }, { "cell_type": "code", + "execution_count": 16, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average value of original data points: 0.650003277874342\n", + "Average value of modified, anomalous data points: -0.02501543656281746\n", + "For reference, these are the average data values of all data points used for training (anomalous):\n", + "banzhaf_value 0.006044\n", + "banzhaf_value_stderr 0.103098\n", + "banzhaf_value_updates 5.000000\n", + "dtype: float64\n", + "These are the average data values of all points (original data):\n", + "banzhaf_value 0.005047\n", + "banzhaf_value_stderr 0.115262\n", + "banzhaf_value_updates 5.000000\n", + "dtype: float64\n" + ] + } + ], "source": [ "print(\n", " f\"Average value of original data points: {plot_data['original_banzhaf_value'].mean()}\"\n", @@ -468,9 +663,7 @@ "print(anomalous_df.mean())\n", "print(\"These are the average data values of all points (original data):\")\n", "print(df.mean())" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -485,32 +678,40 @@ }, { "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], "source": [ "utility = Utility(\n", " model=TorchCNNModel(),\n", " data=dataset,\n", " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", - " cache_backend=MemcachedCacheBackend(MemcachedClientConfig())\n", + " cache_backend=MemcachedCacheBackend(MemcachedClientConfig()),\n", ")" - ], - "metadata": { - "collapsed": false - }, - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Computing the values is the same, but we now use a better stopping criterion. Instead of fixing the number of utility evaluations with [MaxChecks](../../api/pydvl/value/stopping/#pydvl.value.stopping.MaxChecks), we use [RankStability](../../api/pydvl/value/stopping/#pydvl.value.stopping.RankStability) to stop when the change in Spearman correlation between the ranking of two successive iterations is below a threshold. " - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", + "execution_count": 18, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0.0/100 [00:03\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
banzhaf_valuebanzhaf_value_stderrbanzhaf_value_updates
137-0.2649180.09359711
20-0.2173940.12702211
19-0.2103090.08717911
41-0.2101190.07153411
192-0.1916670.13077411
\n", + "" + ], + "text/plain": [ + " banzhaf_value banzhaf_value_stderr banzhaf_value_updates\n", + "137 -0.264918 0.093597 11\n", + "20 -0.217394 0.127022 11\n", + "19 -0.210309 0.087179 11\n", + "41 -0.210119 0.071534 11\n", + "192 -0.191667 0.130774 11" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "msr_df.head()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 20, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "high_dvl = df.iloc[-30:]\n", "high_dvl.index = high_dvl.index.map(str)\n", @@ -553,16 +840,29 @@ " title=\"Images with high values\",\n", " xlabel=\"Image\",\n", " ylabel=\"Banzhaf Value\",\n", - " prefix=\"banzhaf_value\"\n", + " prefix=\"banzhaf_value\",\n", ")\n", "plt.show()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 21, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "low_dvl = df.iloc[:30]\n", "low_dvl.index = low_dvl.index.map(str)\n", @@ -571,12 +871,10 @@ " title=\"Images with low values\",\n", " xlabel=\"Image\",\n", " ylabel=\"Banzhaf value\",\n", - " prefix=\"banzhaf_value\"\n", + " prefix=\"banzhaf_value\",\n", ")\n", "plt.show()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -591,7 +889,9 @@ }, { "cell_type": "code", + "execution_count": 22, "metadata": {}, + "outputs": [], "source": [ "if is_CI:\n", " max_checks = 1\n", @@ -599,13 +899,13 @@ "else:\n", " max_checks = 10000\n", " moving_avg = 200" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 23, "metadata": {}, + "outputs": [], "source": [ "from sklearn.linear_model import SGDClassifier\n", "\n", @@ -621,19 +921,23 @@ " data=dataset,\n", " scorer=Scorer(\"accuracy\", default=0.0, range=(0, 1)),\n", " )" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 24, "metadata": {}, + "outputs": [], "source": [ "def get_semivalues_and_history(\n", " sampler_t, max_checks=max_checks, n_jobs=n_jobs, progress=True\n", "):\n", " _history = HistoryDeviation(n_steps=max_checks, rtol=1e-9)\n", - " _values = compute_msr_banzhaf_semivalues(\n", + " if sampler_t == MSRSampler:\n", + " semivalue_function = compute_msr_banzhaf_semivalues\n", + " else:\n", + " semivalue_function = compute_banzhaf_semivalues\n", + " _values = semivalue_function(\n", " utility,\n", " sampler_t=sampler_t,\n", " done=MaxChecks(max_checks + 2) | _history,\n", @@ -641,63 +945,119 @@ " progress=progress,\n", " )\n", " return _history, _values" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 25, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PermutationSampler requires caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC\n", + "100%|█████████▉| 99.99000199960008/100 [17:48<00:00, 10.69s/%] \n" + ] + } + ], "source": [ "# Monte Carlo Permutation Sampling Banzhaf semivalues\n", "history_permutation, permutation_values = get_semivalues_and_history(PermutationSampler)" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 26, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████▉| 99.98000399920016/100 [09:38<00:00, 5.79s/%] /home/jakob/Documents/pyDVL/venv/lib/python3.10/site-packages/numpy/core/_methods.py:118: RuntimeWarning: invalid value encountered in reduce\n", + " ret = umr_sum(arr, axis, dtype, out, keepdims, where=where)\n", + "100%|█████████▉| 99.99000199960008/100 [09:40<00:00, 5.81s/%]\n" + ] + } + ], "source": [ "# MSR Banzhaf values\n", "history_msr, msr_values = get_semivalues_and_history(MSRSampler)" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 27, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████▉| 99.99000199960008/100 [15:59<00:00, 9.59s/%] \n" + ] + } + ], "source": [ "# UniformSampler\n", "history_uniform, uniform_values = get_semivalues_and_history(UniformSampler)" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 28, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████▉| 99.99000199960008/100 [15:46<00:00, 9.47s/%] \n" + ] + } + ], "source": [ "# AntitheticSampler\n", "history_antithetic, antithetic_values = get_semivalues_and_history(AntitheticSampler)" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 29, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████▉| 99.99000199960008/100 [15:41<00:00, 9.41s/%] \n" + ] + } + ], "source": [ "# RandomHierarchicalSampler\n", "history_random, random_values = get_semivalues_and_history(RandomHierarchicalSampler)" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 30, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Compare convergence speed of both methods\n", "names = [\"Permutation\", \"MSR\", \"Uniform\", \"Antithetic\", \"RandomHierarchical\"]\n", @@ -737,9 +1097,7 @@ "plt.ylim(1e-5, 1)\n", "plt.legend()\n", "plt.show()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -761,7 +1119,9 @@ }, { "cell_type": "code", + "execution_count": 31, "metadata": {}, + "outputs": [], "source": [ "names = [\"Permutation\", \"MSR\", \"Uniform\", \"Antithetic\", \"RandomHierarchical\"]\n", "values = [\n", @@ -787,13 +1147,26 @@ " low_consistency[sampler1_id, sampler2_id] = len(\n", " lower_20_1.intersection(lower_20_2)\n", " )" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 32, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "fix, axes = plt.subplots(1, 2, figsize=(10, 5))\n", "axes[0].matshow(top_consistency, vmin=0, vmax=twenty_percent)\n", @@ -813,9 +1186,7 @@ "plt.suptitle(\"Overlapping high and low value points between samplers\")\n", "plt.tight_layout()\n", "plt.show()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -830,7 +1201,17 @@ }, { "cell_type": "code", + "execution_count": 33, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of top 20 points that all samplers have in common: 0\n" + ] + } + ], "source": [ "all_in_common = set(permutation_values.indices.tolist())\n", "for sampler_id, sampler_values in enumerate(values):\n", @@ -840,9 +1221,7 @@ "print(\n", " f\"Total number of top 20 points that all samplers have in common: {len(all_in_common)}\"\n", ")" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", @@ -856,19 +1235,40 @@ }, { "cell_type": "code", + "execution_count": 34, "metadata": {}, + "outputs": [], "source": [ "max_checks = [1000, 2000, 3000] if not is_CI else [1]\n", "num_retries = 3 if not is_CI else 1\n", "num_samplers = 5\n", "twenty_percent = training_data[0].shape[0] // 5" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "code", + "execution_count": 35, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/45 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Plot results\n", "\n", @@ -960,9 +1373,7 @@ "fig.suptitle(f\"Evaluation of consistency of samplers (Max value: {twenty_percent})\")\n", "fig.tight_layout()\n", "plt.show()" - ], - "outputs": [], - "execution_count": null + ] }, { "cell_type": "markdown", From 61fb08183828d63f58cbdb2245c58f7ece4d0233 Mon Sep 17 00:00:00 2001 From: jakob1111996 Date: Fri, 12 Apr 2024 14:41:55 +0200 Subject: [PATCH 36/42] satisfy linters --- notebooks/support/banzhaf.py | 6 +++--- src/pydvl/value/result.py | 18 ++++++++++++------ 2 files changed, 15 insertions(+), 9 deletions(-) diff --git a/notebooks/support/banzhaf.py b/notebooks/support/banzhaf.py index 13ccd5e7f..f144494b0 100644 --- a/notebooks/support/banzhaf.py +++ b/notebooks/support/banzhaf.py @@ -1,17 +1,17 @@ -import numpy as np +from typing import Optional +import numpy as np from numpy.typing import NDArray from sklearn.datasets import load_digits from sklearn.metrics import accuracy_score from sklearn.model_selection import train_test_split -from typing import Optional from pydvl.utils.types import SupervisedModel try: import torch from torch import nn, optim - from torch.utils.data import TensorDataset, DataLoader + from torch.utils.data import DataLoader, TensorDataset except ImportError as e: raise RuntimeError("PyTorch is required to run the Banzhaf MSR notebook") from e diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index c239456a7..76a7ff28b 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -358,13 +358,16 @@ def __getattr__(self, attr: str) -> Any: ) from e @overload - def __getitem__(self, key: int) -> ValueItem: ... + def __getitem__(self, key: int) -> ValueItem: + ... @overload - def __getitem__(self, key: slice) -> List[ValueItem]: ... + def __getitem__(self, key: slice) -> List[ValueItem]: + ... @overload - def __getitem__(self, key: Iterable[int]) -> List[ValueItem]: ... + def __getitem__(self, key: Iterable[int]) -> List[ValueItem]: + ... def __getitem__( self, key: Union[slice, Iterable[int], int] @@ -390,13 +393,16 @@ def __getitem__( raise TypeError("Indices must be integers, iterable or slices") @overload - def __setitem__(self, key: int, value: ValueItem) -> None: ... + def __setitem__(self, key: int, value: ValueItem) -> None: + ... @overload - def __setitem__(self, key: slice, value: ValueItem) -> None: ... + def __setitem__(self, key: slice, value: ValueItem) -> None: + ... @overload - def __setitem__(self, key: Iterable[int], value: ValueItem) -> None: ... + def __setitem__(self, key: Iterable[int], value: ValueItem) -> None: + ... def __setitem__( self, key: Union[slice, Iterable[int], int], value: ValueItem From 90ad81bfdd32ba478368c3979e405f1ff7791dc6 Mon Sep 17 00:00:00 2001 From: jakob1111996 Date: Fri, 12 Apr 2024 15:21:02 +0200 Subject: [PATCH 37/42] fix bug in least core caused by new updates column in results --- notebooks/least_core_basic.ipynb | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/notebooks/least_core_basic.ipynb b/notebooks/least_core_basic.ipynb index 1aded58ff..5967cfe0f 100644 --- a/notebooks/least_core_basic.ipynb +++ b/notebooks/least_core_basic.ipynb @@ -293,7 +293,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4aef7143d90345c3abcbc1cc6a731af9", + "model_id": "55d514afeb324f01a622948de437baf9", "version_major": 2, "version_minor": 0 }, @@ -341,7 +341,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "43c250efdcf141cb95364b5adc66c72d", + "model_id": "d191d4d6ea024602a5c9ff6399bdf099", "version_major": 2, "version_minor": 0 }, @@ -372,7 +372,7 @@ " )\n", " df = (\n", " values.to_dataframe(column=column_name)\n", - " .drop(columns=[f\"{column_name}_stderr\"])\n", + " .drop(columns=[f\"{column_name}_stderr\", f\"{column_name}_updates\"])\n", " .T\n", " )\n", " df = df[sorted(df.columns)]\n", @@ -406,7 +406,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -457,7 +457,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -547,7 +547,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d89e8aac1ce4453f9e4d097bee9d8d2e", + "model_id": "9395b5d2928a4919b5395fdf05107722", "version_major": 2, "version_minor": 0 }, @@ -602,7 +602,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABlkAAALGCAYAAADGEfdTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wcd50//td7Zpu0RdVN7l7LlktcYjuJbQihE0gudI4SAqHX0I4zdwfk4L6HA3ehBfhdDkIucMlRLhRxtFBCcRoxTgM7xXGv2lXZ3mY+vz8+M9rVemVrJdmSrNfz8diH7N3ZmdndmS3zms/7LUopEBERERERERERERERUX2MiV4BIiIiIiIiIiIiIiKiqYghCxERERERERERERER0SgwZCEiIiIiIiIiIiIiIhoFhixERERERERERERERESjwJCFiIiIiIiIiIiIiIhoFBiyEBERERERERERERERjQJDFiIiIiIiIiIiIiIiolFgyEJERERERERERERERDQKDFmIiIiIiIiIiIiIiIhGgSELEREREdVFRLwi8s8i8qSI5EVEichLJ3q9RkNE7hYRNdHrMVYi0ikiPxCR487r0T/R60RTk4i8VkR2iUjS2Za+MNHrNJ2IyH4R2V/H9EpE7j57azTxpsNjrJeIXO88L5dN9LoQERERQxYiIqJpS0T+0fmBrkRk+USvD00pHwbwCQBHAfwbgH8GsGdC12gYInKrs40vmuh1OVtExATwQwAvBvAT6Ndj+0Su01Q13Q/mishmAP8NIAzga9Db0s8ndKVoypjMB/5FZJGzbrdO9LpMJiJymfO8XD/R60JERDSVeSZ6BYiIiOjcExEB8FYACoAAeBuAj0zoStFUcgWAFIDnK6UKE70yY/RGAI0TvRJjtBjASgD/qZR6+0SvDE1pL4H+THijUuqeiV4ZIhrWTQD+B8DBiV4RIiIi4kgWIiKi6eoFABYB+C8AxwFcIyK+CV0jmko6AMTPg4AFSqmDSqlJOQqnDh3O36MTuhZ0PuC2RDQFKKViSqk9SqnMRK8LERERMWQhIiKart7m/P1P6NIw7QBeNtzEIjJPRL7k9ODIikiviDwgIh8f7bSnK8tTq8RTZakPEVkmIt8RkZMiYrulSURkg4h8UUQedpabc9bj30Wk5TSP7zUi8uuK++wXkTtEZKNz+zucZX9ymPvPFpGiiDw63DKqpn+TiPyviDztPEcJEdkhIm8YZvolInKziDxV8Zw+KiL/n4i0jXCZLxWRb4vIEyKSdi47ReT9IjKi74Tu6wI9cmJhRbm5/c7tpy07UqvXgPNcKOfvs0X3SEk6z8n/iciKYebVKCJ/LyIPOtOnRGS3s+3NcqZRAK5x7rKven2daWr2ZBERQ0TeKSJ/cuaddv79rlrPl7s9i0i781odE92v5i8i8uYzP7unzG+Ds42cdOZzQES+KiJzqpcL4HfOfz9Z8RivP8P8K/enLhH5obNdpUXkjyLygtPc97Ui8lsR6Xf2l90i8k8i4j/N8zJbRL4uIkdExBKRN1VMc5Ho/fmI81iPicgvReTVNeZ3sYh8X3TvmYKIHBKR/xCRjhrT3u0s3yMi/yDlHkKHROQGqQiW3e3Q+e+zKp7HIc+l1LnvOvfZ5Dwed7v+lYhsltOUVnJek1uddS2IyAkRuV3qLO040u244vG722rl/rLoDMsYfBwi8joRud9Z1v6KaRpF5GMi8pCzDikRuVdEXltjfoPvIyKyUUR+LiIDItLnPPfznemWiMj/iEiP81r8VkTWDrOOc0TkK6LfgwrOfe4UkQ1V021zln3dMPPpEJGSiDxYdb1HRN4tIvc5r3FGdF+b90rt9wtxbvuL6H3oiIjcJCJNp3uuT8dZt2+Jfs/Iin5/f91ppn+hiPxURGLOfrFXRD4nIs01pl0j+jNxvzNtj4j8WUS+ICJeZ5r9ANzPyN9W7kMjXH+fiHzcWY+8iOwTkX+RGu8rFY/3E87+574fHHX2k5VV014PYJ/z32tk6P79porlv9d5Tg4469Aren+9fCSPoXJ5FfvENc62kHVem1tEZPYw9+sUkduc7cF9PLeJSOfpllF1/Yg/i0SXTvut89/Kz4/B+TrPy/ud17vP2bb3i8iPROR59TwvRERE5zOWCyMiIppmRB+A/hsATyil7hGRBHSPjbcD+E6N6TcC+AWAVgC/B3AndHmllQCuB/Dp0Uw7BlEA9wN4AjogagCQcG57G3RY9DsAv4I+oWQDgA8BuFxELlZKJSvWVwB8E/pAfMxZ3x4A8wA8G8DjAB50lvNZAG8RkX9RSllV63Qt9Peq/xjhY/gagL9AP0fHALRB99P4logsV0oNBlKiD6r/CUAEwE8B/C+AAHTQcTV0yZD4CJa5HYAN/dwdAdAE4DkAvghgkzOvM/khgP0APuD8/wvO3/4R3PdMrgBwFYCfAfj/oLeZFwPYJCIrlVIxd0LRgdlvAayFfo1uAVCA3jbeDP06noDuJ/FSZ7ovVqznSNb3WwBeB+AQgK9Dl9Z7GYCvAngGgNfXuE8zgB3OunwfgB/AqwDcIiK2Uuq/RrBciMgV0K+zOPM5AL0dvwvAVSLyDKWUe8Dwn6FHpV0Dvd3f7Vx/N0ZmMYB7ATwKvf3OAfAaAD8TkdcppYa8J4jILdDP8WFnHfsBXAK9bz9XRJ6vlCpVLaMVwH3QJebuhN4OTzjzexv0/mAB+DGAJwHMBLARwLsBfLdi2dcCuBlA3pn2EIBO6NKHV4rIJUqpWqVzbgfwTOhtKwG9XX3UWY570PEh6Ofyk9DP960V97+74t8j3neddb4UwC8BmM5j3wvgAujt9zc11hUi8iJnWi+AbgBPQb8nvRzAS0Tk2UqpP9e6bw0j3Y7dx/9SjG5/AfTnyPOddf4t9HsMnIP2vwGwHsCfofdXA8ALAdwuIquUUv9UY36bAPw99Hb9n9DP28sBrBaRqwD8EboX1G0AFjq33SUiS5RSKXcmIrLYmbbDWY87AMyH3jdfIiKvUEr9pOL5+n/QZQS/WGOd3gD9Wt5aMX/3dXoh9PvR7QBy0J8hXwZwMU59f/0CgPdDb0M3AyhCv/9dDMAH/R5SjxYA90C/Vt+Efi96NYD/FpG5SqnPVU4s+oSB6wH0QvdxOglgDXTZ0BeLyGalVMKZdg3054aC3u/2QX8eLYXeR//JWf8vQG8/z4IeJbt/pCvvfBZ/F/o52Av9ueaD/my9YJi7XQpgG/S29r/Q7y+dAF4J4G9EZKtS6mFn2rud5+Q6AA9Df5a5HnL+tkK/5vcAuAv6u8AcAFcC+KmIvE0p9fWRPibHB6FHDn8HurfRM6Dfcy5zvo/0VDwHm6C/t4Shn+e/AuiC3uauEpHnKaX+NMLlNmNkn0U/dP5Wf34A5dfvVgCvBfAY9L6Whd6XngHgRc46ExERkVKKF1544YUXXniZRhfogxIKwMcqrnsQ+sDn0qppfdAHVBSA19WY17zRTOv8XwG4e5h1vNW5fVHFdYuc6xSAfx3mfgsBmDWuf4tzv7+vuv7tzvUPAGiqus0EMKfi/zc5015RNZ0AeBpAunoep3kNojWu8wH4NfTBqrkV17/PWe51Ne4TBNAwhmUa0AfDFICL69iG9gPYX+P6y5x5XT/S+wF4k3OfEoDnVt32Gee2j1Zdf7tz/dcAGFW3hSpfh1rbUtX0d+uvxEOue61znz8DCFU93w/W2sYrts2vV26D0GFRCcBfR/jchqBDMwvAM6tu+3tnGb+s53kfZjmV+9Pnqm7b6GyHfQAiNV6rO6u3O+gDtqdspxXLuA2Ap+q2lc5yegGsqrGOle8vy6APGD5VuX84tz3Xeb5+UOu1BbATQGvV6/iUc5/ZNdb37jr3o+H2XQM6NFIALq+6zzsrnpvLKq5vcZ73GICVVfdZDX0g+c8jfI1Hsx3fitPsL8Msx33t0wDW17jdnWf1fhyAPvBsA1hXY3tWAF5fdZ9vONf3AvjHqts+Psw2+Avn+urpt0Dvm/Gq58edfnWNx/IX6JCvrcbj/zKG7vtmxfpeVbVc5WyDrVXPx73Obfurl32a5999rr6LivdD6AC1F3q/WVJx/bOd6e8B0Fw1rzc5t32+4rp/r34MVdtr5TLd5+Kyka6/c7/XOfe7F0Cg4vpW6NDllP0SOiQN15jXWuj95GdV1y9y5nPrMOvgR9X3FOf6JuiAoRcj/7x1n4cCqvYJAJ93bvtGxXUCYPcw2/xrnOv3jOS5rtgeRvRZhNN8fjiP3YZ+v6j13aptuOeAF1544YUXXqbbheXCiIiIphHnbNG3Qv9ovq3ipluhf+S/reouV0IfmPixUur26vkppQ6PctqxcEconEIpdUCdOsoE0GdOJ6DPNK70PufvO5RSA1XzspRSxyqu+po7bdU8XgB9MOs71fMYjlJqb43rCgC+Aj0i5rk17patcZ+0UuqU6+tYpo3y2drVz8259j9KqV9XXXez8/ci9woRmQl90OkYgI84j2GQUio10tfhNK51/m5TFWfEK6XS0EEHoPejahkAH6rcBpVSf4U+o3iFiIRGsOyroA8sfkcp9Yeq2/4dOqh6vogsGMkDGYEBAJ+qvEIp5Y7easbQMoLXQR+ku7bGdvdp6IPVtUb4FKBfq+oRLu+C3t4/rZT6S/Wdqt4z3gU9suM6pdSRqul+DX3m95UiEq6x/L9XSvVWTJ92Hp8BHSiNWJ377hbos/1/q5T6WdXdboYejVftjdDP+yedbadyOY9Bj+hYX10OaRij3Y5H62al1K7KK0SXM3wDgAeVUp+tvE0plXPWQ6APslf7o1Lqv6uuc8/AH4AenVfJ/UxbV7H8edDv0QehRyNWLv8e6FEtrdCjYKqXcU3VY9kIfaD6/5RScec6A/pz5DiAD1bt+xb06B6FofuFO3rq/1VtlzkAH8PoWNDb+eD7odKj3b4Evd9UjqR5v/P3bUqp/sqZKKVuhR7ZUWs/rvUZ1Ff9HjxK7nPyD87z4M6/F8OMgFVKnVQVI1Mrrn8YesTSs51RRiOilMrX+p7ifJ7cAh0obRrp/Bzfqt4noMORAQCvqyiFtgV61Mq91du80qMJ/whgOfTokZEYj88iQG+7Ah0snvI6u/sBERERsVwYERHRdPMc6JJKv6g6UHk79AHcN4nIPymlis71lzh/qw8Q1lLPtGPxsFIqX+sG54DKOwD8LfTBsCYM7UE3t2LaIPSZ4SdqHAQ5hVLqLyLye+iyY/OVUoecm97u/P3/RvoAnAPkfw99QHYBdMmzSnMr/v1jAP8K4Csi8kLos6x3QJ+NqupYZhuAv4MubbQE+mz24ZY5ER6scZ37HFf209kE/Zr+3jlYfDZcCH1A6e4at/0O+oDm+hq3PamcEjtVKh9Hqsbt1csGapSSUkqVnG1wkbP8WqWx6vXnWgcqoR/7Nc5y/ktEGqHPEI8B+IDOa0+RB1Crh85+pdTJGtfX856x2fn7LKesTrWZ0CMHlkGPXKk00m3rjOrcd91t5I/V81FK2SJyj7O+ldzHuVZq99Vxp18BXU7odEa7HY/WAzWu2wT9ugzXJ8g9CF5ru6n1uh11/j5UI1B3P9PmVVznPr4/VHyuVfoNdAi0HuWQ5gfQB8FfLyLbKpbjhi63Vtx/GXRI8ySAfxpmv8hi6ONz9/Hf1Zj2j9CvS70OqnIJwUp3Q5fAq3ydN0OPunqViLyqxn18AGaISJtzEP070AHrD0Xk+9DloXbUChzHwN1WT9lXcJrShyLyEuhRYRuhe8tVH99ohw7kR0REVkF/Tl4KXSosUDVJvZ+Tp7zGSqkBEXkIuqzaCuhQa9j3/YrrnwH9Ov5+BMsdj88iKKUSItINfRLNQyLyvwD+AOB+pVRmBOtBREQ0bTBkISIiml7cQODWyiuVUr3OD+lXQJ9J/33npmbn75Azx4dRz7Rjcfw0t30H+sz7pwH8yJnWDWQ+AF0OxNXs/K1nfb8KffDlrdBNYmdD97d5SClV6wDjKURkCfTByBbogxW/hD6gZ6HcW2NwPZVSB0TkIuizX1+E8hnXh0Tk35RSXxrBMpuh+7osdpZ9G3TpkxLKdeprNhc+h/qrr3BCBUAfpHU1O3/P5nbWBKDXGaFQa51i0Af1q/UPMz93BIc5zO3VywaGPzDoXt88gnmNxIlhrnf3M3d9WqDPaJ6BcnPrkRpun212/o7ktWxz/v7dGaY75Qzt6rP1HfW8JgDq33dRfu6Ge45rXe8+zupRhdVGcib6aLfj0ar1OruPZxNOPwqg1uOpNSKtNNxtFe8XlaMX6t6flFJZEfku9GvwAuj+RD7o8ms9GBoKuo+vE6ffLyof37DbRcXrUq+R7seAXmcPzrwfhwDElVIPiMgzAfwjdL+TqwFARB4H8M9KqTtGsb7V3G21VhBW8/1DRK6D7gPTB91D5SD0CA6Fcm+hEX+uicgl0GGGB7r834+hR8Da0KOjrqpnfo6Rvi7j/b7fP8z1db/vQY8c/Xvo0WbuKOKcE7h9RCk13GMkIiKaVhiyEBERTRMiMgP6wAMA3CEiwx0YeTvKIUu/83ckZ2/WMy2gD4QM912k+Qz3O4VTyuVl0GfZXl5Zmsgp6fLRqrv0O3/rOTPVbaj+FhH5FOpveA8AH4I+yPVmpzTLIBF5LapK1ACAUmo3gNeIiAf6wNHzoEvUfFFE0kqpb5xhmW+FDlj+WSl1fdUyN0OHLOPBLSdyute1f4zLcO9/NkfeDABoFRFv9UE/5zVohz74draWDQCzh7l9TtV0YzVrmOvd5Q9U/d2llLqwxvSnM9yIq37n71zofgOn4y6/aZgztM+Fevdddz2He45rXe8+zrVKqUdGuZ6V8zqX23Gt19l9PJ9XSn1oHJc1UqPdn/4LOmS5BjpUeQn0a//FqufSvd8PlFIvx8i495kFfULAoIrXpd7ymiPdj91/G0qp1pHOXCl1L4ArnPJWG6AD//cBuF1EepRSY21+Puy2ihqvnfM8XQ8dVlyohpb2dD/X6vVP0CPTnq2Uurtqfh+DDlnqVe/767l63x8xpzTk9QCuF5H50CeavAl6BNgiAM881+tEREQ0GbEnCxER0fRxDXQZkJ3QzXhrXXoAPE9EFjv3uc/5e/kI5l/PtIA++3R+9ZUiYqKipn4dljp/f1yj98NFqCrr45SaegzALBEZUckc5+DP16EPCl8JHV6koPs71Lue/1vjtmedYfklpdROpdQN0GdVA+Xg7Kwss059zt9ar+tSDD2berQegA5zLnVKvp2JW3qnnjN3d0F/T760xm2XOvP6cx3zq4dbuu6y6hucA4vuAa3xWv6Fw/QxcZe/C9C9bqCbfq8SkREfnD2D0by/nO0DejaG31bq3Y/c1/KUPgpO8Lulxn3G83FO5HbscvfXiToQO/gaOPtPtWc7f4c8D0qpHdAlwK4SkSaUA7T/wlB7oMPCS+ro/+Euq9Y28wzU917lWiAii2pcf5nzt7Ik5n0AWpzSWHVx+pbco5T6BMq9XSrDh9G83wL6OTFQu+fIZTWua4cO7e+pEbCEUC6/VelM67YUejTN3TVuG+3n5Cn3c7andQBy0M3ugdO87ztqbqfjZMSvmVLqkNMz5oUAnoLer9rOcDciIqJpgSELERHR9OGWn3m3UuqttS7QIzIE5WbI3dCNtv/GOVN7CKepMEYxLaAPvi0QkRdUXf9PABbW99AAZ9lA1UEKp1H6V4a5j1tq6z+cAx+V9zNEZE6N+9wMfVDiJujRIbcP09Oi3vV8IWo0oRaRDdXr5nDPkB1JXfThlrkeo2+0XMse6DPjr3Ked3c5DSg/12OilOoB8D/QZ/b+m3OwepCIhKqeL7cxbz2N4m9x/n7G6UXizrsR5WbbZxo9NFo/hC7l9lqnfE2lD0Bvc79SSo1HPxZAB1+fqLzCGRX2euizpn9QcdON0EHtLU4JOlTdr0VE6hnl8jXo8jUfr9XIveo94yboPhKfF5HqPiYQEZ9T0mis4qgREjr2O38vq1p2zX0XunfSXugG3NVB0ttxaj8WAPgm9EH7TzplAodw3pcuq75+GBO5HQPQzcmhQ+iNIvJxJ0QfQkSiFcH+eC//MHQpqUXQ+0/lci+GLoHUh6Hbueu/oHtyvBu6l9Uj1f27nED/y9DvR19y3uuGEJE5Vdv3rc7ff6wMLEUkAOAzI390Q5gAbqh8P3Se0/dD72Pfrpj2887f/xSRjhrrG6x87xGRLbUeF2p/Bo3m/RbQ2z0A/D/neXCX3Qr9naDaSWe5G6SiibsTdH0ROoSp1gc92mq4ddsPPZpmTeWVIvIW6FBhNK6ucRLH9dDvu3dU9JfbAeBx6NDilVXLfyV0SPkEavesGathXzMRmSEiF9S4TxC6nFwJwCnlCImIiKYjlgsjIiKaBpyDcssAPHqG3iHfgK67/mYR+aRSqiC6Me4vocuCvAP6LNgAdMPW58L5PlHPtI5/gz5w8SMR+Q70geUt0AeR78bwZ3QO50/QBypeLrqh9B+hDwJdDn3w4miN+3wd+uDF1QCeFJEfQY/m6QDwHOiDlNdX3kEpdVBE/g+6FwtQX6kwQPd1eTOA7zk1zY8CWA1dfuW70PXPK10N4B0i8kfoA7Z9AKLQI2ny0DXpz+Q26F4WXxCRZ0Ofod0J4AroEmjVyxwVpVRRRL4I4OMAdonID6Bf8+dDP85ar8FovBf6OXsngMtE5BfQB3oWQ29Tf4Nys+RfQz/2/xTdtDcJoF8pddNpHsftInIVgFcD+IuI/BDlOv+LAXzHOZt33CmlUiJyLYDvAfidiHwPutfABuj+EMcBvGMcF/l7AG91DjjvgD5Y/Brok7HeUVmaSyl1i4hsgD7ovNd53g9CN/5eDD064pvQr8sZKaX+KiLvBvD/QW8vP4LeNtug+3ck4JzBrZTa4zwvt0C/Jj+HPujohT44+EzofbdrDM8FoLeXvxXdo+rP0MHO75VSv0ed+67T3P6tAH4O4MfO9rcXwBrofeJn0O9PdsV94s5B1R8AuE9Efg09gkhBhz+bneenuiH3KSZyO67yXuj3m09BH3T+I3TZxQ7oz4ZN0CPzajVuHw/vhN62P+eE+g9CP5evgn7u3zxMUP4tZ53/GXo7qx7F4vo0dBnHdwK4UkR+A91naCb0494K/bn6V0CPkhGRL0OX23rM2ZaK0CNC+lBHo/YKjwC4GMBOEfkl9CiPVzt/P1rZpF4p9WsR2QYd6DwpIj+Ffu5D0Cc4PAv68/NFzl0+CuA5IvIHZ7oUgFXQ224f9IkHrt9CP6efEZHVzu1QSv3LGdb/Duj952+gn5MfQT/nr4T+bI9WTuzsW18CsA3Ao870Puj3i1ZnPZ5ddZ+UiNwP4Jki8t/Q7x8W9OjXR6A/S18I4I+ie/IMANgIPbrm+8661OtnAHY48zvmzOsZ0IHOtop1UyJyDXQg+B3n8ewBsBx6f00CeKNSysb4exx6e/1bESkCOAD9PvEt6P5Tu0TkUeht7BCACPR3h9kAvlTnSSZERETnL6UUL7zwwgsvvPBynl+gzyRWAN4/gml/6Uz7sorrFkAfYNwHfTA7DuB+AP9Q4/71TPs30Ae8cs50/wN9kOdWZx0WVUy7yLnu1tOse6uz7P3OPPcC+FcAjc51+4e53+sB/A76oErOWff/hq71Xmv6q5x1+dMoX48t0A12+6APnvwR+kDKZc58r6+Y9mLoM/4fhg6istBlOr4JYHUdy1wJ3cj3JIA0dNm4t47kea0xr9M9lwJ98Giv8/ofBPDZ4V4D6NruCsCbhpmfAnB3jeuD0AcuH4E+ozkJfRDzCwBmVk37IeiyLHlnfvsrbrsb+hhX9fwN6DDhQWf+Gec5ew90P4MRradz2ynb8wie403QB9p7Kp7HrwHoqDHtKdvNCOY/+LpDH+j+kbM9ZqAPSL/wNPe9AsBPnG2pAB38PADgXwB0jfR5qZhmM3QJLnd+R6GDiVfWmPYCZ50POK9nL3TZv/8A8JyqaWu+tqfb7qAPjN8OHQJY1c8r6th3q/bhu5zpk9B9ozZDj85RANYN8/rcBB065aADpz3QBz5fWsfrXO92PJpt9XrnPpedZhofdNhyD/T7bN7Zpn8NPcKkbSTbM87wfjXc9gZd4vFrznZTABCDHjW26QyP7VfOPIsAZp1mOoEOxH/tbJMF6APXfwTwDwDm15j+vSi/Lx2FHnHZhNO8v57uMUOHVt+G3o9y0CHh605zv2dAh4NHnfXtAfAQ9Ii1jRXTvQD68+avzmuXhj4w/yUAC2vM9w3OfLLOutXcB4fZRj4B3acm7zwP/w+62fwpryt0gP8hZ72y0O9D38Iw3yGc+yyFHnUbhw6DhrwHQL+33QcnjIf+PuT2IBn2c+p0+4RzX/f56HGeyznD3G+58xiOOdvcMec1XT7S/a7Wc3Wm/Rv68+bXzuvrPi+XQYd0n4B+zzvivC7HnO3ttQBkpNspL7zwwgsvvJzvF1FKgYiIiIhGTkSuB/BJAG9VZ246TzTpiO7fsA/Afyml3jSxazM9icgO6ACmSekeUUR0Hqj4jvBsVbvHCxEREZ1n2JOFiIiIqA6im4S/E/ps5TsmeHWIaBITkcZh+te8CXpUzC8ZsBARERERTW3syUJEREQ0AiLyEgAXQvdCmQXgI0qpkTSdJ6LpawF0T4O7oMv8eQCshy7V1A/gwxO3akRERERENB4YshARERGNzKsAXAPdq+EzAD4/satDRFPACej+Ts+CbsTth+4d8U0A/09VNCQnIiIiIqKpiT1ZiIiIiIiIiIiIiIiIRoE9WYiIiIiIiIiIiIiIiEaBIQsREREREREREREREdEoTPueLCIiADoAJCd6XYiIiIiIiIiIiIiIaFIIAziqztBzZdqHLNABy+GJXgkiIiIiIiIiIiIiIppU5gE4croJGLKUR7DMA0ezEBERERERERERERFNd2HowRlnzAwYspQllVKJiV4JIiIiIiIiIiIiIiKaOLrLyMiw8T0REREREREREREREdEoMGQhIiIiIiIiIiIiIiIaBYYsREREREREREREREREo8CQhYiIiIiIiIiIiIiIaBTY+J6IiIiIiIiIiIiIpoydO3eGAcwBBxFQ/WwAxzZs2JAcrxmKUmq85jUliUgEwACAJqVUYqLXh4iIiIiIiIiIiIhOtXPnTgPAP5im+UYR8QKQiV4nmnKUUqpoWdZtAP51w4YNdq2J6skNOJKFiIiIiIiIiIiIiKaCf/B6ve+aPXt2IRgMZkRkeo8goLoppSSdTjceP378XcViEQD+Zazz5EgWjmQhIiIiIiIiIiIimtR27twZMU3zwY6ODu/MmTPjE70+NLWdPHmy7ejRo0XLsjbUKh1WT27AmnVERERERERERERENNnNFhFvMBjMTPSK0NTnjITyQvf2GROGLEREREREREREREQ02RkAhCXCaDw425FgHDIShixERERERERERERERESjwJCFiIiIiIiIiIiIiIhoFBiyEBERERERERERERHREK94xSsWzZ0794KJXo/JjiELEREREREREREREdEE+tKXvtQmIhvci8fj2TBz5sw1r3jFKxbt27fPO9HrR8PzTPQKEBERERERERERERER8JGPfOTo4sWL87lczrj//vuD//u//9v+pz/9KbRnz56/NDY2qolePzoVQxYiIiIiIiIiIiIiokngyiuvHLj00kszzn9j7373u0tf+9rXZt9+++3Nb33rW/smdOWoJpYLIyIiIiIiIiIiIiKahC699NIUAOzdu9cPALlcTj7wgQ90rFq1akU4HF7X0NCwfsOGDcu7u7vDlfd7/PHHfSKy4ROf+MSsf/u3f2ufP3/+ap/Pd+Hq1atX/O53v2usXs63vvWt5s7OzlV+v//Czs7OVbfddltzrfVJJBLG2972tnmzZ89e4/P5Lly0aNHqT3ziE7Ns2x4ynYhseOMb37jglltuaYlGo6sCgcCF69at63rggQcaAOBzn/tc+4IFC1b7/f4LL7roouWPP/64b3yesXOPI1mIiIiIiIiIiIiIiCahffv2+QCgpaXFAoC+vj7z9ttvb7/qqqt6r7nmmlgymTS+/e1vt7/85S/v/N3vfrd7y5Yt2cr7f//7329Np9PmNddc0yMiuOmmm2a/5jWvWXrgwIFH/X6/AoA777wz8qY3vSkajUaz//AP/3A4Ho973vOe9yyaPXt2sXJetm3jhS984dL7778//OpXvzq2du3azF133dX06U9/et6RI0d83/jGNw5VTn///feH7rrrrqZrr722BwC+9KUvzX7pS1+69H3ve9/xb3zjGzOvvfbanr6+PvNrX/va7GuuuWbRfffd98TZfC7PFoYsRERERERERERERDTl2ApIFydXtaagF7Yho79/X1+feezYMU8mk5E//OEPwc997nMdPp9PveIVr+gHgBkzZpQOHjz4aCAQGOzPct1118W6urpWf+ELX5i5ZcuWA5XzO3bsmO+JJ554bMaMGRYAdHV15d7whjcsvfPOOyOvfe1rBwDgH//xH+e1tbUV77333sfb2tosAHj2s5+devnLX97Z0dFRcOd1++23N993333hj370o0duuOGG4wDwsY99rOfyyy9f8s1vfnPmhz70oZOrVq3Ku9Pv378/8Mgjjzy2fPnyAgC0tLSU/u7v/m7hjTfeOOeJJ554rKWlxQYAy7LkK1/5yuzHH3/c5047lTBkISIiIiIiIiIiIqIpJ12EsfprWD/R61HpsXdhV9gH+8xT1vbSl750WeX/Ozo6Cl//+tf3RaPRIgB4PB54PB4FAJZlIRaLmbZtywUXXJB+9NFHg9Xzu+KKK/rcgAUAXvCCFwwpP3bgwAHvnj17Gt797ncfdwMWAHjZy16WiEajuWw2Oxhi/fSnP20yTRPbtm07WbmMj3zkIyd+/vOft/zoRz+KrFq1qse9fvPmzYnK0GTr1q1pALj88sv73YAFAC655JL0V77yFTz++ON+hixERERERERERERERDQqn/nMZw52dXXl+vv7zVtvvbX9T3/6U9jv9w8Jbb785S+3ffnLX561b9++QKlUGhw3M3fu3FMCigULFgy5zg1c+vr6TAB46qmnfADQ2dmZq77vkiVLcn/5y18G+7ccOnTIN2PGjEJlQAIA69atywHAgQMH/JXXV69Pa2urBQDz588fcn1zc7MFAL29veapz8jkx5CFiIiIiIiIiIiIiKacoBf2Y+/Crolej0pB7+hHsQDAli1b0pdeemkGAN7whjf0b9y4sevNb37zkieffPKxpqYm+6tf/Wrr+9///kXPe97z+q+77rrjs2fPLpmmqW644YY5Bw8e9FfPzzRNdepSAKXUGIqajYxp1s5MJnKdzgaGLEREREREREREREQ05RgCjKU012Tn8XjwL//yL0euvPLKZTfccMPMf/3Xfz1+5513tsybNy//i1/8Yq9hlNvRfOpTn5o7mmUsXbq0AABPPvlkoPq2p59+esh18+fPL9x7772Rvr4+o3I0y8MPPxwAgIULF+ar5zEdTKqmQEREREREREREREREpF1xxRXJCy64IH3zzTfPymQy4o4OUao8GOQ3v/lN8KGHHjqlH8tILFy4sNjV1ZX93ve+1xaPxweHnvzgBz+I7N27d0jI8uIXv3jAsix89rOfnVl5/Y033jhLRHDVVVclRrMOUx1HshARERERERER0YTZvqsYBNACQAD0bFvvPaUvABHRdPbBD37wxLXXXrvkpptuan/xi1/c/8tf/rL5BS94QfTyyy8f2Ldvn/9b3/rWjGg0mstkMqMaVPHpT3/68Gte85rOzZs3L3/9618f6+3t9dxyyy0zly5dOmSer33ta/tvuumm5A033DD3wIED/jVr1mR+9atfRX796183X3vttSdXrVo1LUeyMGQhIiIiIiIiIqJzYvuuogGgGTpUaQUwF0A7gCB0yDKwfVfxKIAjAGIAYtvWe0sTs7ZERJPDG9/4xr5PfvKT+ZtuumnW008//djx48e9t91224w//vGPTdFoNHvzzTfv+973vtdy3333hUcz/1e+8pWJW265Ze+nPvWpuf/6r/86b/78+fmvfOUr+3/0ox81V87TNE384he/eOrDH/5wx49//OPW733ve21z584tfPzjHz98/fXXnxi/Rzy1SOWwoulIRCIABgA0KaWm5XAmIiIiIiIiIqKzYfuuoh/lQGUGdKgSAdDoTJIBkHIu4twWAeADkAfQD+AggBMAegD0b1vvPW/7LxDR8Hbu3Nnl8Xh+3tnZmWpsbOSINxqTTCYTePLJJ0OlUulFGzZs2FN9ez25AUeyEBERERERERHRmG3fVRQAYZRDlTkAZgEIQYcmJQBpAH3QI1Vq6XUuAOCHDlwuBGA6941v31U8AB249Gxb702dlQdDREQ0QgxZiIiIiIiIiIiobtt3FT3QgUoLgDYA85x/BwEYAHLQI1SOACiOYhF5OGGK83+3d8t8AApAcvuu4gkAh5xpYtvWe6dlPwAiIpo4DFmIiIiIiIiIiOiMtu8qNqI8SmW2c4kACACwoUeapKBLe52Nkl5p5wLoECcMYAGAZdAhzsD2XcUjAI5Chy6929Z7rbOwHkRERIMYshARERERERER0RBOg/omnNqgPgRduqsIHaichB6xcq7Z0LXyB5z/e6EDn1UA1jrr1OeUFnP7uSS2rfdO7+bEREQ07hiyEBERERERERFNc9t3FX3QYUoLyg3qmzC0QX0augl9aSLW8QyKAOLOBQAaoEOXi6BHvSQBxCr6ucS2rfdmJmJFiYjo/MKQhYiIiIiIiIhoGnEa1IdQHqXSAWAmdPmtygb1/dClt6bi6I+sczkBwH28MwEsBmABSGzfVTwG4DB06BLftt47mr4xREQ0zTFkISIiIiIiIiI6jzkN6ptxaoP6EIY2qD8KoDAxa3lWKeiRLEnn/yb0KJcogJXQj7l/+67iQZRLi/VtW+89G31liIjoPMOQhYiIiIiIiIjoPLJ9V7EB5dJfswDMgQ4VGjC0Qf1JnJ0G9ZOdBaDPuQB69E4EwDroY2VplPu5nATQs229N1ljPkRERAxZiIiIiIiIiIimKqdBfQTlUGUe9GiVMPSIjRKcfiTQ5bPoVAXo5yfm/L8Ruh/NFjijYLbvKvZA96Nx+7nkJmJFiYho8pmUIYuIvAfA3wGYDeBhAO9TSj0wzLR3A3hWjZt+qpR6yVlbSSIiIiIiIiKic8xpUN+CUxvUB51JstCjVCZrg/qpIONcAF1OLQT9PC+Ffk4T23cVjwA4gnI/F2siVpSIiCbepAtZROQ1AG4E8E4A9wP4AIBfiMhypdTJGnd5OfSwTlcbdDDzvbO8qkREREREREREZ9X2XcUQyqNU5kCX/woD8EOXvUoBGABwDFOzQf1kZwNIOBdAH0uLAOgCcAF0Pxu3n8tx6NBlYNt6L18LIqJpYtKFLAA+BOA/lVLfBAAReSeAlwC4FsD26omVUr2V/xeRv4U+24Ahyxgs/CKM9+z7z/ebsL/24S+8Iz/R60NERERERER0vtu+q2hCN6hvdS7znf+HoEt/5aFLfx3D+dmgfiooAeh1LgAQgB5JtAH6NUoBiG/fVdyPcmmx9ASsJxERnSOTKmQRER/0h9Jn3OuUUraI/ArA5hHO5i0A/kcpVfMDTET80Gd7uMKjXN3z2jsPfPMdz4n/4fP7Ghd+7vJ/feLO/S2d39y4wP7dqg47v229dzo2xSMiIiIiIiIaV9t3FQMoj1KZCV2SKgzdE0Sh3KC+B9OzQf1UkHMuJwAIdNm2dgALoF/DxPZdxeMADkO/jj3b1nuLE7SuRER0FkyqkAX6Q8iE/mCqdAJ6GOZpichFAFZDBy3D+RiAT452BaeLgnijWTOAaGa/5xOP3/Dq/5r3t6/+ZfG5yb8e9zx4/z7r3nXz7V1+D9LQZ9FkARSdS6nib6nGdUUAJdYqJSIiIiIioulk+66iYGiD+rnQx0HC0MdnLOhRKnHoA/I09SjoUCzl/N+Afs0XQR/XKkCHLgehRyPFAPTyZFYi+tKXvtR23XXXLfrd7363+9JLL82c+R7nxs6dOwP//d//3fqOd7wjtnz58hGPoLznnnsabrjhhtn3339/uLe319PQ0GCvWrUq85rXvCb+nve8J+7xTLZYYmzOr0ejw5VHlVIPnGaaz0D3fHGFwS8vp/jkv7/hIz95y66v5cX7y9ZSYsnbD96Gjf27wjctetuz/5xqefbDh410a1A9srhdPXRBh/20zzPsGTUl6C+K7qUEwN6+q1iEDmjy0Gd8uH9rBTPV17n/tljjlIiIiIiIiCaj7buKXugwpRW6f+x86APuQegRDznoUOUQ2KD+fGUD6HcugO4pHAGwBsCF0OXu+7bvKh4AcBJ6lEvi1NkQEU2MRx55pOHzn//8nOc85znJkYYsN954Y/tHP/rRha2trcVXvvKV8c7OznwymTTuvvvuyAc/+MFFx44d827fvv342V73c2myhSwx6APxs6qunwXdPGxYIhIE8LcAPnG66ZRS7oF9936jWtHp4Ipv/PveHZdf3plvDN7gawh84MLEo56vPPZ39s3zry7dPeNZwZ6UbO5JYfODB4x0OID75zXbOzYssB8K+uEOexXoszZM5+Kp+HcDyjVlPRXTuferDE+sGhc3rHEDGndETR7DjJ7BqSGNO6qGQQ0RERERERGNyfZdxSDKvVRmQTepD0H37LChRzckoY9v8Hfo9FSAPvYVc/7fAN3P5RLoYyHJ7buKPQAOolxaLDcRK0pENBq//vWvgx/96EcXrl27NvWrX/3qyZaWlsET8z/xiU+c/P3vf9/40EMPNYx1OZZlIZ/PS2Nj46T4PJ1UIYtSqiAiOwE8F8APAUBEDOf/N53h7q+C7rXy7bO5jtPN1p/9zO6ORj8aWbDgDw2zZn2lwYt51x34uu9VR+7s+fq818b+0rp+fsHwhwayeM5A1nzOX48b2bAfD8xtVjs2LrT+HPKjAB2KjIUbwFSGNCYAL/SX1eoQpzqkAfQX2pphjTOqJgv9ZcetpVqr/Nmwfzm0l4iIiIiIaPpwGtQ3oVz6a77zb/dkwgJ0oHICFSd6ElXJOhdAH8sIQYdzUejjDYntu4pHARyBDl3i29Z7OeqJaBrbt2+f96Mf/ejc3/zmN03JZNJcsGBB/r3vfe/xD3zgA3F3mlwuJ9u2bZtz1113NR08eNBfKpVk5cqVmeuvv/7olVdemayc380339zyxS9+cfb+/fsDIoKOjo781VdfHfv4xz9+0i1hBgBXXnnlMvc+3d3dT1xxxRVD5uP653/+5w4A6n/+53/2VQYsrksvvTRTWQ4tkUgYH/7whzu6u7tbe3t7PR0dHYU3vvGNPddff/0JwzAG7yciG66++uqezZs3p/793/99zv79+/3f/OY3n7766qv7R/KcnG2TKmRx3Ajgv0TkQQAPAPgA9FDabwKAiNwG4IhS6mNV93sLgB8qpc7ZkzddXLl3rwLw4/9bseJAczT6mUBz84s6Sr0z/uHA14JHn/Y/cG94XXLn3GfP2R9eurQIb3Mih2cljsuz9hyXXDiAB+c0qR0bF1gPRhpG/cXSdi5jaQxnOJfqoMYDHc41oTyixgP95cZVGdoMV/6sAP0lOlv1d0QhDfSIGn5RIiIiIiIimoScBvVu6a92APMwtEF9FjpUcSt0ENVLQW9D7oFLD3RpsWUALoA+IbTf6edyHHpb62N1DprulFKwcznjzFOeO0YgYJ+N6kmHDh3ybN68eYWIqGuvvfbkjBkzSr/4xS8iH/zgBxclEgnzE5/4xEkA6OvrM2+//fb2q666qveaa66JJZNJ49vf/nb7y1/+8s7f/e53u7ds2ZIFgB/84AeRd7zjHUs2b96c/PjHP34YAHbv3h249957QwBOPu95z0u+6U1vOnnrrbfOfO9733t8xYoVWQBYu3Ztttb6JZNJ49577w1v2rQp1dnZecbSYrZt44UvfOHS+++/P/zqV786tnbt2sxdd93V9OlPf3rekSNHfN/4xjcOVU6/Y8eO8E9+8pOWa6+99mR7e3spGo3mR/qcnG2i1OR7LxaR9wL4OwCzATwE4P1Kqfud2+4GsF8p9aaK6ZcD2APgBUqpu+pcVgTAAIAmpRTrXp5BdzTaFZw1682RhQvfbHg8MwCgPxDZfTxjP6DSaeuRec8M3r/ghXMO++euKsJsc+8nUIWQXwcuGxZYDzY3oubOOMkJdDAzXFhj1Ph39f0VqgKain9b0F+a3JCmsk9NPWHN5NupiYiIiIiIpginQX0Y5dJfcwDMhB5l4IX+7eaW/pqKv21panJPEI1AH1/IAIgD2A89yiW2bb03NWFrR3QO7Ny5s8vj8fy8s7Mz1djYmAMAK5s1Hn7729dP9LpVWnvzzbvMhoa6qt6MpPH9a17zmoW//e1vmx555JG/zJ49ezDQv/LKKxfffffdTceOHXs4FAqpUqmEUqkkgUBg8BhhLBYzu7q6Vj/nOc/p/+53v3sAAK699tr53/ve99r6+voeGq4R/Te/+c2Wa6+9dsnpRq+47r///oZLLrlk5Zvf/OaTt9xyy6HTTQsA3/72t5uvvvrq6Ec/+tEjN9xww2CrkMsvv3zJL37xi5ZHH330sVWrVuUBPZLFMAw88MADf9mwYcNgGcWRPie1lp/JZAJPPvlkqFQqvWjDhg17qm+vJzeYjCNZoJS6CcOUB1NKXVbjuscxdOQBnSVX7t27pzsa/Xq2t/dQ6/Llr/JHIpc25xIrgh7PnIMLFv5mde/DR9Ydvjtt+QJ/3bXkBeYDc547/5jRtq5oy+xkHluSJ2XLkyelGPTjz7MjaseFC6wH2oKo+cYxCSmUmxGOqNHTMMxhLj7os6CqQxzg1BJoleXPhoQ1VeXP3LDGHVVTHcpU96th+TMiIiIiIppWnAb1zSg3qJ/n/N9tUJ+HDlSOYGwVFojGIg/gpHMB9PbplqpT0P1cjgM4BD3KpWfbeu9Yjl0Q0SRi2zZ+9rOftVxxxRV9Sik5duzY4HH95z//+Ymf/OQnrffcc0/jC17wgrTH44HH41GA7l0Si8VM27blggsuSD/66KNB937Nzc1WNps1f/jDH0Ze+cpXjnnwQX9/vwkA4XB4RCM6f/rTnzaZpolt27YNGW3ykY985MTPf/7zlh/96EeRVatW9bjXb9q0KVkZsNTznIz1sZ3JpAxZaHK7cu/eJ7ujUSv22GO58Lx5j4XnzXutF6WWJX37XxoPtT90ZNbqezzxE9kNT/60ecMT/3e4FGl79MEVL1V/at7U2VNsuLhoSUcqj4uf6pGLn+qRUtCHXbMj6p518+37Z4bVdDjrwg1HxsIdKVN9ccufNVddXyuErBxVUzmaxnKCmlrlz840moblz4iIiIiIaFJzGtS7pb9mAehAuUG9BT1CwO2nwhPQaLJKOxdAHyOIAFgIYDn07/KB7buKRwAchR7p0rttvZel7Oi8YwQC9tqbb9410etRyQgExv2z49ixY55kMmnecccd7XfccUd7rWmOHz/udf/95S9/ue3LX/7yrH379gVKpdLgccG5c+cOhq8f/vCHT/7oRz9qedWrXtU5c+bM4qWXXpp4zWte0zvawKW5udkCgGQyWV3dp6ZDhw75ZsyYUaju3bJu3bocABw4cMBfef2CBQuGtKKo9zk5mxiy0KhcuXfv093RqJU8fNjOxuOH2lasuMITCGxtT8cuDGcHOva3R/+Ya2rbb2SSBU+ir2nzvTc3Xtxw++HsvKX3P9j5Es8uz/LVvRljS8GSBekCNu2Nyaa9MbGCPjw8M6x2rJtv3zc7ok47BG2aG48+NW75s1qXIPTw+MoRNUbVfd2RNdUjakrQQU0J5VE01eXP6glrWP6MiIiIiIhGZfuuogF9EpobqsyF7qkShP69U4Au/cUG9TSV2QD6nQugy9pFAKwCsBb6N3nf9l3FA9AjYXoAJPh7m84HIoJ6S3NNRZalM9Krrrqq901velOs1jSbNm3KAsBXv/rV1ve///2Lnve85/Vfd911x2fPnl0yTVPdcMMNcw4ePDgYXMydO7f0l7/85a933nln5Kc//WnTb3/726bvf//7bS972cvid9555/5613HlypV50zTV7t27G0b3KE+vsvwZUN9zcrYxZKFRu3Lv3gPd0ehdpWz2uSf+/OfvtnR23t/Q1vZOP4qzl53cc9XJ4Mz7jrZ27Fb+hrgUC71mOhEKPvXIskv3/bW4uX3OU5nl6+9+YOELfLsHwhfH07K1YMmidAEX7ovLhfvi8p5GHx6dGVI71s6z7+toVv0T/XjPQ275s7GOOKk1msaAHlETxMjKn1kY2p+mMqzJQ//YcUOayvJnZwprCtvWezmcn4iIiIhomti+q+jHqQ3qI9ClmQE9SiUFNqin81sRul9L3Pl/A/R+cDH07/EUgJgTuvRAlxZjfyGiSayjo6MUDAZty7Lw0pe+9LQnpt95550t8+bNy//iF7/Yaxjlc6Y/9alPza2eNhAIqNe97nUDr3vd6wYsy8LVV1+94I477pjx2GOPHVu9enVeREYcxobDYfuSSy5J3nfffeGnnnrKu3Tp0tMek5s/f37h3nvvjfT19RmVo1kefvjhAAAsXLjwtCc/1POcnG0MWWhMrty791B3NPpLAM/re/JJycZi72uORq8zfb41s9InnxnJ9nXsm7n8gUKgMQbD6LfCzSnJZX3enqMzmk4cnPPc8O/7tyxZ9af0ms0/ebhxVdOe48aWeFq25ksSzRSwdn+vrN3fK+9q8OIvM8Jqx5q59r3zW1TvRD9uGuJslT/zoFz+zIORlT8b0p8GQHH7rmI/gGPQjaoGAAzwyyMRERER0dRX0aDeDVXmQJf/CkH3vCxBl1Pqg+6nQjRdZZ3LCejf0yEAMwEsht5PEk4/l8PQoUucJywSTS4ejwcvetGL+n784x+3/ulPfzq2adOmXOXtR48e9XR0dJQAwDT1Oc5KlfOR3/zmN8GHHnooOGfOnMFyYcePHzcrm8Wbpok1a9Zk77jjDuRyOQGAUChkA0BfX9+ISoB98pOfPHr55Zd3ve51r1ty1113PdnU1DRklNEf/vCHxoceeqjhfe97X/zFL37xwB133NH+2c9+duZnPvOZwcb3N9544ywRwVVXXXX6ZvN1PCdnm1Q+2dORiESgD7w2KaXG3OBnuuqORmcDeC6AmRB5uq2r6wp/c/M1IuK1FTLHQzPvPt624ISZTsaNfFYf4LZKhifRFzFymZAdaMgUOhYfS6/YeDR9wSW9TyYaZ/z1mLEllpKt+ZIsKy9JqYAXe2aE1I7VHfY9i9pUzaFgNC3VKn/mhT5jrcG5vQB95toAdPDSj3L4kuJQaSIiIiKiyWv7rqIHOlBpQblBfQvKI+hz0GfoJ8EG9UQjZUKPcmmC/g1dhP6tfBDAcejQpX/beu95X46JJr+dO3d2eTyen3d2dqYaGxtzZ77H1PGlL32p7brrrlv0+te/vqejo+OUz7CPfexjJ1KplHHJJZes6O3t9bz2ta+NrVy5Mtvb2+t56KGHGnfs2BEZGBh4CAC++MUvtn3gAx9Y9JznPKf/8ssvH9i3b5//W9/61oxZs2YVM5mMceTIkUcB4PnPf360v7/fc+mllybmzZtXPHDggO+WW26ZOXfu3MJjjz32V9M0cfDgQc+SJUvWrl69Ov2Wt7ylx+/32y95yUuSc+fOHTa8+NznPte+bdu2he3t7cVXvvKV8c7OzlwymTR///vfh3/zm980f/SjHz3ymc985rhlWdi6deuyBx54IPy3f/u3sTVr1mR+9atfRX796183X3vttSe/8Y1vHHLnKSIbrr766p7bbrvtYOWyDh065BnJc1JLJpMJPPnkk6FSqfSiDRs27Km+vZ7cgCELQ5Zx0x2NzoQOWmYDeLpx1qx5TQsXfsjweJYAQAaeXXtnLd9V8votM9kfE6ukd0alYGSSjWayvxmGYZVaZ8Uyy9cfTq17xslS2+zCvpjMeEwHLltyRVlRucyARz3eFlL3rJpj3xOdoU6c68dMU44X+gdYo3MRlBtbpqC/QMah3xMS0DVqWUKAiIhomti+q+iepGEDKPIEDKKJtX1XsRFDG9TPgT4YHIDeT9PQ3+PTYIN6ovHigw5cItABTBpAL4DK0mLsoUsTYjqELMPd/tRTTz0SjUaLR44c8XzsYx/ruOuuu5pisZi3ubm51NnZmXvFK17R++EPfzgGALZt4x//8R9n33bbbTNisZg3Go1mP/GJTxz93ve+13LfffeF3ZDl1ltvbf76178+Y/fu3Y3JZNJsb28vXnbZZQPbt28/umDBgsEQ5cYbb2z//Oc/P/vYsWN+y7LQ3d39xBVXXHHa94E//vGPjZ/97Gdn3XfffeG+vj5PY2OjvWrVqszrXve6+Lve9a64O9pmYGDA+PCHP9zx4x//uLWvr88zd+7cwhvf+Mae66+//kRlqbPhQhYAGMlzUgtDlnHEkGV8dUej7QCeB91M8CnxeIz2FSv+1hsKvVJEDNtWvUcb23/WM2NxXgq5tJlJDlSOXZNCzutJ9DZLsei1Qk2J3KIVh9OrNp3Idl2YAIADvdL22BFjc09KtmSLWAXIYNkov0c91RZUO1bOse/pnKmOnfMHT1OViXLo4ja/tKGHUqegmwLGMLTcGM+KIyIimqQqghL34qv6f+X1Dc4l4Fx80N8N3DKkbk+4LPRJGXnoM3zdS6Hq/4MXBjRE9XEa1Dfh1Ab1Iej9sgj9/TwFvV8S0bkRhA5cQtCfj0no38kHoX8r92xb7z1t3wSi8XI+hyx07jFkGUcMWcZfdzTaCj2iZQGAvQCs8Lx5XaG5cz9omOYcAEhb8tunZy57rBgMh4aUEHPZlpjJ/oiZSYZsXyBXnL3gRHrFxiPptVtjdkPQBoDDfdLyyBFj88mkbMkWsRqQwXjT51H72oJqx/JZ9o4VsxVr71K9DJQPugSh+8Io6B9zGejRLsdRHvHCPi9ERETjqI6gxAsdjgRxalDi9ndz/y3OpfIHUAnlXm4W9EFc92z46vu75UirWRXzqJwfAxqi09i+q+iDDlNaAMyADlWaMLRBvTtS5ZzUUyeiMzKgw5Ym6N/LJejfxUcAHEW5nwsrQtBZwZCFxhNDlnHEkOXs6I5Gm6GDlsXQQUvJDAQCbV1d13obG18EAJZlHT7qbf5hbHbUA8Mwh5QQq2BkUg1msq8ZAKzm9t7MsnUH02u2nCzMWTj4Znp0QJoePmxccjIpWzMFrBkSuJjqYGtQ7Vg2U+1YMcc+aNRqmU40MgGUR7z4ob9gFqB//PVDNxHsQ3nUS5oHSYiIaLqqEZScLjCpJyipVisosWpcf7Y+k42qdawOZs4U0FSvZwk6nHEDmixGFtAUAJT43YMmI6dBfQjlUSod0E23wxjaoD4FHa5wOyaaGjwY2s8lB/3b+AD07+Me6JMSuU/TuGDIQuOJIcs4Yshy9nRHoxHooGUJgKfhnH3UtHjxxuCsWe8Xw2hWSlmZgvWjp9uXPl5qbp8lxXzGTCf6UWPDlGLBNBO9zUYhH7AaQ6ncwuWHsys2Hk+v3NQPs/yb9URCwg8dNi4+kZCt6QLWAuJxb/Oa6nBro9rROVPtWNVh72fgQuPAh3K5sUboAy0l6B+HSQDHMDR4SbBhIBERTRVO+Z5aochwQUkjyuW3KoOSygBiJEHJcIHJ+fbj5UwBjdf5a9S473ABTRZDQxo3oBl25AwY0NA4c0LWWg3qQxjaoD4Fvf0R0fkhAB24hKE/71PQ/Vz2o9zPJTNha0dTHkMWGk8MWcYRQ5azqzsaDQF4NoDl0EFLEQC8oVC4ddmy93gCgS0AYBWLjx+1/Xf0zutqthoam2qWEHPZNszUQNhMJyLK6ysU2ueczK7YcCS17pk9Vrh5yEiYnhSCuw6ZF51IyNZUHhcOCVwMdawlqHZE29WONfPsvQxcaBy5fV6Czl+3z4tb8uAknDN6UC43xj4vRER0VowiKHFDkkaMT1BSwtBSWtP7B8j4GW1Ao6C/l4xHQONez4Bmmtu+q9iAcumv6gb1CmxQTzQdCfRv4ibnrw39+/c4gEPQv4lj/C1M9WDIQuOJIcs4Yshy9nVHo0HooGUFdNAyeKZSy7Jlz25oa3uniDQopXKZVPpb+5sWPF2YvWDh6UqIuYxs2m8m+5rFts1SpLU/27nmYPqCS07kFyw75cyIvjQadh4yNx0fkK2pPDYoiM+9zWOoEy2N6p7F7WrH+vn2Ewxc6Cxw+7y44YsP5T4vaeiGgSdRHvEysG29l18YiIgIwGmDklqhyViCklq9RRiUnH/c8mXDlTY72wFN5XUMaKYY5/0ognKoMg96tEoYerspQY/oTkNvC0REgH5/CEOHLn7oz4IEgIPQFSBiAHpZ+YFOhyELjSeGLOOIIcu50R2NNgC4DMAq6GGiefe2QGvrjOYlSz5g+nwXAICVzz94NFX8dv+i1TNKze1zTldCbFCpZHgSvU1GPhu0A8FUft6SY5mVm46mV1/cp7y+U+43kEVg50Fz49EB2ZLKYZOC+N3bPIaKNTdgx6J2+54L59t7TIMHEeisanAubh16gd4/0tDvTcega9omwD4vRERTmnNg8kyN3GsFJQ3QByNqHQw/3UHwM40s4ecJjcZwAY0XI982q8O86oAmh9OXNmNAcw5t31X0onaD+qAzSRbl0l9sUE9EI+WDDmwj0J8dGehS2/uhT0CMbVvv5XE6GmLnzp3LPB7PL5cuXZoKBoMMWWhM0ul04KmnngqVSqUXbNiw4Ynq2xmy1IEhy7nTHY0GAFwKYA30mQrls5pEpG3Fir/xNzVdIyIeZdvJdLz3a4dDsw7mFyyLWg3B5tOWEHMpBTOdCBqp/iaYHqvYOrsn23Xh4dS6Z5wstcyoOQQ1mYPvwYPmhqP9sjWpA5cG9zbTUL3NDbhnYat9z4YF9l89Joe20znh9nkJQh9Yc/u8pFG7z0uSZ/sQEZ0bYwxK3BEl9RyMZlBC55N6Ahp323ZHXNXa/qsDmjTOXNqMAc0ZbN9VDKEcqsyBLv8Vhg57LZQDFTaoJ6Lx1IhygCvQv317oI8fuf1ceFB9mtu5c2ebaZr3L168uNTU1JSa6PWhqW1gYCC0b98+j2VZF23YsKG3+naGLHVgyHJudUejfgDPBLAO1UELgOCsWQsiCxd+2PB4FgNAMZv9zcnjsdv6l66bU5g1byEM84wlxFySz/o8id5msSyPFWpKZJesOpi+4JITuejqYd+E03l4HzxorD/Sb2xN5HCxUtLo3maK6m9qwL0LWu0dGxbYj/k8DFzonPJAf+l0L6Zzfdq5nID+4umOeEmwti0RUW0jDErcizvicCRBiaB8wPF0Z+0zKCGq32hH0AC198ESyuHMcAHNcIHNeRPQOA3qm6FDlVYA853/h6Cfzzz0gU42qCeic8mAfh+KQP/+LUH/1j0C4Cj0b9/4tvVejp6bZnbu3GkYhvH7tra2xQsWLDg20etDU9vBgwfnxOPxfbZtX7phw4ZTjvMyZKkDQ5Zzrzsa9QHYCuBC6A/IdOXt4vF42leseK03FHqFiBi2ZfWkjx37/AlP+Fi2c+1Sp4RY1kwn+k5bQsxlWeJJ9jUZmVTIDjRmCnMWHM+s3HQktWZLr/I3DBuUZAvwPHjQWHu4z9iayOESW0nIvc0QlWxqwL3zW+wdGxfaj/g9sEb9hBCNntvnJYhyzX0FHV5moGvankB5xEuCZ/4Q0fmiKig5UzP3eoKSSiMNSiywkTPRZFYd0FTv+6MNaLIVlykR0GzfVQygPEplJnTprzD0d8nKBvUp8H2NiCYPD8qlxXzQ78ED0CfvHocOXfrPlwCcTm/nzp0v9Xq9X541a1YpFAqlRdhYmeqjlEIqlQqeOHHCUywW37thw4Yf1ZqOIUsdGLJMjO5o1AtgM4BN0GchnDK6JDxv3orQ3LkfNExztlJKFdPpH/Xs3Xd7snPtzPzC5W4JsV4jnz2lyX1NSsHIJBvN1EATAFVqnRnPLF9/KL32GSeKMzpOe1ZWvgTzwQPGBYf6jK0DWWy2lUTc2wxRqUgA989rsXdsXGA/1OBjHWKaUIJyo+MgdFkHQP/QT0OXGTsB3efFDV8y/DJKRBNhnIKSsTTqZlBCRGdSGdC4l/EIaDIoBzUjCmjqHaW8fVdRMLRB/VwA7dChihflBvUpsEE9EU0tfujSYhHo998UgDiAAyiXFksPf3eaynbu3GkA+Jhpmq8VKZ8QTVQPpVTKsqw7AHym1igWgCFLXRiyTJzuaNQD4BIAF0GfeZCsnsYTCDS0dnVd621sfCEA2KXSwcShQzf2F9Sx9MqNiwuz5i9ySojFxSqN+EeHFPIeM9HbbBQLfisYTuYWrTiUWbXpRGbZ+gGY5mnvWyjB2HnQWH2w19gykMUWS0nz4HxFZSIB3D+3yb5nw0J7V8jPIfU0afhQHvHi9nkpQv/AT0Dvg70olxtjnxciqosTmLghSAC1gxL3Nve9aKRBCXD6viQMSohoMhpJQONBue9MpeHe74YLaCqDmUYAbdClvyLQ3wENZ3o3VOGJYUR0PglChy4h6O+CSejfuIegQ5fYtvVeHp85z+zcuTMCYDZq/3agEbIgUoJpGrBtL+zp8lvKBnB8w4YNpw9OGLKMHEOWidUdjZoALnYuPdCvxSmalizZFJw5831iGM1KqVIhkbg9vnv3nZmFXc3ZZW4JsUJuxCXEXLYlZrI/bGaSYdsXyBdnzjuR6dpwJLVua8wORs5YAqxkwdh50Fh5oNfY0p/FFsuWVvc2gcqGA/hTR5O6Z+NC68FwgIELTTpunxc3fDGhP2jcMhE9KO+Xbrkx/iAnmoa27ypWBiQNVf92SzcEoUMTN1ypddYCgxIiopFxA5rhSpudLqAR6PdRt+xXGuz9RETTh4Hy99MAdPg8AB24HIMuqx3nSYU02TkjUg2UvxPUunjOcLt7qTwBrvpkOPckt14AP2alkzKGLHVgyDLxuqNRA8BGAFugh3f215rOFw5HWjo73+sJBC4BAKtY3D3w9NM3ppOpnvTKTfN0CbFQs5lOjLyEWAUjkwqYqf5mKGVYTa3xbOfaw6m1W08UOhaPaOi8ZUP+fMjo2h8ztvRlsdWypd29TaDyoQAenBNROzYutB5sagD7YtBkZUAHLu7FB/0j3T1rsge63Jg74mVg23pvfmJWlYjGyvni7kc5NKkMURpRLsPgjkxxLy6FoWdQ5yv+zx+uRERERDTRvCh/p/VAj+rrgy4tdgI6dEnwwDLVw/kdNdbgw522OvjwVVxvoBy0GKe5nIl7Iptd9W/3EoI+zvNtBpBlDFnqwJBlcnCClvUAngEdsvQON23LsmXPbWhre7uINCilcrne3q/3Pv74L4utMxvSqy5aXJw5f6EyTU+9JcRcUiyYZrKvycjnGqyGUDo/f+mRzKpNx9KrLu47Uykxl2VDHjpsdO6Lyda+jGwp2TJrcP5QhZAfO2c3qR0b5lt/agmy/jFNem6fF3fEi9+5zg1eejG0z0uC9W+JJp5Tvmu40SchDG0eWvml3mXj1ODEDVOm9xdIIiIiIpqq3JHYYejftW4VhwPQgUvPtvVeHqeZwpzfQWMNP9zRpMNdPKgdflT/v9aI00rVYUflpVYYMtxlrNqd5TFkqcCQpQ4MWSaP7mhUAKwD8Ezo+pmx4aYNtLbObF6y5AOmz7caAEr5/J/6nnzyy4VEoj+7eGVrtnNNtNQyo2NUJcRctg0zPRAyU4km5fEWijM6ejJdFx5Ord3aYzW1jbhkkq2ARw4b0b0x2dqXlq1FW+aUb1WlkB9/nhVRO9bPtx6YEQIPTNNU4kd5xEt1n5cBnNrnJcUPa6LxcZryXQGUz9Q7XfmuEoaGJu6/WRKQiIiIiKYLQfnkoyD0QeYB6LJiR6DDl/i29d66T+ClU42w/NVIA5Fa/R+rA5DTXU53FrWC3jZGGnKcbrqpcuCdIUsNDFnqwJBlcnGClgsAPAv6QO3J4aYVwzBau7qu8jc1XS0iHmXbiUxPz039e/feZ/v8RmbFxrm5RV1LrYZQs5lJ9hm5zKgDDMllfZ5EvAW2bVqRlv7sktWH0ms2n8gv6qprnrYC/nLUWPTkSdnam5FnFC2ZW75VlYI+PDwronasm2ffPyuikqNdX6IJ5EF5xEsj9JcXG3p/TqE8HHsAOnxhnxeiCs4PDx9ODU4aULt8lxc68HRVl+8qVFz4ZZmIiIiIaHgm9HftJujv2nnoig2HoE8i7AHQfz4ehD5D+at6QpBa5a8qL+eq/NVIwhAqY8hSA0OWOjBkmZy6o9FVAC6D/kA7cbppg7NnL4osWPAhw+NZBADFbPbXvXv23FzKZrPF1pkN6ZWbFhVnLVikTNNrJvtjoykhNsgqGZ5EX5ORTTfaDcFMfu7io5mVm46lL9jcq7y+unYmWwG7jxsLnjghW3rTsrVgycLyrcpu9OGRmWG1Y+08+76OJjUw6nUmmnhunxc3fPFCf6HJQocvMej9fADlPi+FiVlVorNnhOW7wtA/SPwo/xAR6PCE5buIiIiIiM4dH8onOZkA0tDVGg5AnxTcs229N3W2V+I05a/qHf0xkvJX1QFIveWv3N8ttYKPc1n+iurDkKUGhix1YMgyeXVHo13QQYsNPVRzWIbH42lbseL13lDo5SIitmWdTB879oXEwYOPAUB20YrW7LK1Yy8h5lIKRjoRNFMDTTBMq9g2K5Zdvv5Qau3WnlLb7FEdHN59XOY+fsLYGk/LlkJJllQszG7w4rGZYXXPmrn2vfNaVN+o15to8hCUz8xvhD7QrKAPHrt9Xo5jaPCSmZhVJTqzqvJd1SFKPeW7qkefcKQXEREREdHkEIT+Xh+C/v2ahA5bDkKPcklg+HJYYyl/daa+H2cqf+WaTuWvqD4MWWpgyFIHhiyTW3c0ugw6aDGg62GeVnj+/JWhjo4PGqY5Symliun0D+N//eu37FKpNFhCbOHypVZjqNnMpMZUQswlhZzXk+htllLRZwWbBnKLVx5Or77oeHbZulGX+3rypMzZfczYEkvLlnxJOsu3KNXgxV/bQ2rHBXPtexe2qvhY159okvGjPOIlAL3vFzC0z0sfyuXGktvWe6f3BxmdVRXlu2qNPmlEefRJI4Yv31XCqaNPWL6LiIiIiGjqMqB/BzRB/z4oQVdrYPkrmooYstTAkKUODFkmv+5oNArgOdAHrw6eaXpPINDQ2tX1Vm9j4/MBwC6V9icOHrwxffz4fgAoNs8IpFdftLg4a/5CZXp8Yy4h5rIsMVP9ETOTCtm+QK4we8HxzMpNR9JrNsfthuCo36CejsnMvxw1tsRSsjVXkuWVtwW8ak97UO1Y3WHfs7hd9Yz5MRBNTl6UR7xU93lJQgcvvSiPeklsW++1JmZVaSo5TfmuAHTY1wyW7yIiIiIiojPzQP+OYPkrmooYstTAkKUODFmmhu5odBGA50IfBDswkvs0L1lycePMme8Vw2hSSpUKicR/x3fv/oGybRuoKiFWKubN1EDvmEqIVTDSyQYz1d8ECErN7b26lNiWE8VZ8/Njme/+uLQ/dtTYHEvJ1mwRKwAZrIXp96gn20Nqx4rZ9j2dM9XxsT8KoknNxNDgpbLPSxp6qPZJlEe8sM/LNLN9V9GD2s3jAyg3s3TLd7mNGVm+i4iIiIiIiKYbhiw1MGSpA0OWqaM7Gl0AHbSEAOwfyX184XBTy7Jl7/X4/RcDgFUs/rX/6ac/n4vHTwCA7fMbma4NHblFXUutxlCLmUn1G7nMuDUtk2LBYyZ6m4xCPmA1hpK5hcuPZFZddDzTtaEf5kjKZQ7vUJ+0PnLEuKQnKVuzRawCZHD4qd+jnm4Lqh1ds+0dy2epo2N+IERTQ2WfF/fguQDIodygsLrPS3ZiVpVG6zTlu9zRJ275rgaUR5/4UR59Uqt8lzsahV8miYiIiIiIaLphyFIDQ5Y6MGSZWrqj0bnQQUsLgH0YYTmW1uXLnxdobX2biDQopbK53t7/7H388V+5txebZwQyqzYtKsxesEh5vH4z0dczLiXEXLYNM9UfNtPJiO3zFYoz5p7IdG04klr/zB47GBlzWaOj/dL88BHjkpNJ2ZIpYE1l4OIz1f7WoLpn+Sx7x8o56tBYl0U0BQVQHvHSAH2wvbLPyzHoPi8J5/8p9nmZGFXlu6pHn7jlu0LQoUll+S5Av64WTh15wvJdRERERERERMNjyFIDQ5Y6MGSZerqj0TnQQUs7gKcxwgNngba2Wc1LlnzQ9HpXAkApn7+/74knbiokkwPuNLmFy1syy9cvLZcQS/RB2eP65mJk034z2dciSkkp0tqX7VxzKLVmy4nCvOi4nFF/PCHhhw4bl5xMyJZ0AesAGRwy4zXVodZGtaNzprpnVYe935DTzIjo/OaFPmjvhi/uAfoMgBT0iJc4yqNekuzzMjZO+a5azePd8l1hlPufuOW7PCi/x1uo3Tye5buIiIiIiIiIRo8hSw0MWerAkGVq6o5GZ0EHLbOgg5YRvQGIYRitXV0v9Tc1vUFEPMq2BzInT97U//TT97vT2B6vkVm5qSO3cHnUCkZazUxyXEuIDSoVTU+ir8nIZxrthlAqP2/pkfSqjcczKy/qU17fuOyYPSkEdx00Lz6RlK2pPNYD4nFv85rqaEuj2rF0htpxwVz7aQYuREP6vAShD/C7fV5S0D1eYhhabmz8RrxNUVXlu2qFKM04tXyXW8pNoJ9jt/9J5ciTAvSXPCIiIiIiIiI6exiy1MCQpQ4MWaau7mh0BnTQ0gFgL+qopR+cPXtRZMGCDxkezyIAKGYyd/Xu2fP1Ui43OJrkrJcQcykFMzUQMtOJJmV6isX2OT2Z5esPp9Y/86TV1DZuZ2jH02j880HzouMJ2ZrO40IFcUvswGOoEy2NaseSdrVj3Xz7SQYuRIMM6HCgATp48UOPrMhBj3qJo9znJYHzrM+LU77Lj9qjT4LQzePDzjQ+lEehAOUApbp0F8t3EREREREREU0eDFlqYMhSB4YsU1t3NNoKHbQsgA5aRnzWs+HxeNpWrnyDNxh8mYiIbVknUkePfj556NBfK6c7FyXEXJLP+jwDvc2wSx4r3DKQW7LqYHr1xSdz0dXjOpKmP4OGnQfNjccGZGsqj40K4nNv8xiqp7kR9yxus3esn28/bho8EEpUg9vnxQ1eDOjwIA2gHzp46Ud51Et6svV5GaZ8l3txwxO3/8lIyndV/iUiIiIiIiKiqYEhSw0MWerAkGXq645GWwA8B8Ai1Bm0AEBkwYLVwTlzPmCY5kyllCqmUnfGd+/+b7tUGhxFYnu8RmbFxjm5RV1LrWC41cykzk4JMZdVMjyJvoiRy4Rsf0OmMHfxsUzXhUdTa7b0Kn/DuL7ZJbLw7zxobjg6IFuTOWxSkIB7m2mo3uYG3LOwzd6xYb6922OOfLQQ0TTkQ7ncWCN08FKCHvGSBHAMQC/Ko14SZ+PLS43yXZVBSnX5Ll/FheW7iIiIiIiIiKYfhiw1MGSpA0OW80N3NNoEHbREoYOWuspseRoaGlq7ut7ubWh4LgDYpdL+xMGD/54+fvxA5XSlpjZ/evXFiwdLiCX7e6RUPHtnbSsFI5NsNFP9TRBDlVpmxjNdFx5Mr9lysjijozDei0vl4XvwgLn+aL9sTeRxsVLS4N5miupvcgKXC+fbf/F5GLgQjYDb5yXo/HX7vGSgR72cBNCD8oiXxOn6vAxTvssNT4IoN5AP4NTyXYAehVIdnrijUab3FwIiIiIiIiKi6YkhSw0MWerAkOX80R2NhqGDlmXQQUvd4UdzNHpJ44wZ7xXDiCilSvmBgW/17tnzI2UPLQ+WW7CsObN8/dJS68y5Z7uEmEsKOa8n0dckxYLPCkZSucUrD6ZXbTqR7brwrGy32QI8fzpgrD/Sb2xJ5HCJrSTo3maIGmhqwL0LWux7Niy0H/V7eHY7UR3cPi9u+OJDuc9LGkAMwAkAKeiA5HTlu8yK+Vo4NThh+S4iIiIiIiIiOh2GLDUwZKkDQ5bzS3c0GoQOWpYD2Ad9gLEuvkikuaWz830ev38TAFiFwmP9Tz/9hVxv78nK6YaWEIu0mpnk2S0hNrhgS8xkf9jMJMO2L5Arzl5wItN14dHUumf22A3Bs/JGmCvC8+ABY82hfmNrIotLbCVh9zZDVDISwH3zW+x7Ni60Hw546xtFRESD3OClETpYEed6hXJgwvJdRERERERERDSeGLLUwJClDgxZzj/d0WgjgMsArIIOWvKjmU/r8uXPD7S2vk1EAkqpbDYev7nviSd+XT1dqanNn165aVGhY9Hic1JCrIKRSQXMZF8LAFjN7b2ZzrWH0mu3nijMWZg7W8vMl2DuPGisPthrbB3IYrOtpGlwfUSlwwHcP6/Z3rFhgf1Q0M8z6ImIiIiIiIiIiCYxhiw1MGSpA0OW81N3NBoA8CwAFwA4AF2Gp24N7e2zmxYv/qDp9a4AgFIud1/fk0/eVEgmT9lWJqKEmEuKBdNM9DYbhXzAagyl8guWHcms3HQsvXJTP0zzzDMYpZIF48GDxsoDvcbWgQy2WEpaBtdJVDbsxwNzm9WOjQutP4f89Y8qIiIiIiIiIiIiorOKIUsNDFnqwJDl/NUdjfoBXApgHXTQkh3NfMQwjLYVK17mi0ReLyIeZdv96RMnvjywb9+fqqe1PV4j07VhTm7xiqVWMNxqZtP9RjZ99kuIDa6ADTM1EDbTiYjy+gqF9jknsys2HEmte2aPFW4+q2W8ShaMXYeM5fvixtb+LLZatrS5twlULhzAg3Oa1I6NC6wHIw2jG11ERERERERERERE44ohSw0MWerAkOX81h2N+gA8A8CFAA4ByIx2XsE5cxZH5s//sOHxLACAYibzy949e75RyuVOCW90CbGNCwsdi5ec6xJiLsll/J5Eb7PYtlmKtPZnO9ccTF9wyYn8gmWjfg5GyrIhDx02lj0dM7b0Z7C1ZMvMwfWCKoT8eHB2k7pn4wLrT82Nowu/iIiIiIiIiIiIaMwYstTAkKUODFnOf93RqBfAFgAbARwFMOqRJYbX621bseJqbzB4lYiIbVnHU0eOfD55+PDuWtPn5nc2Z7rWR0stM+eKVSqcyxJig0olw5PobTLy2aAdCKby85Ycy6zcdDS9+uI+5fWd9TcAWwEPHzaWPh2Trb1p2VqyZbZ7m0AVg378eXZE3bN+vvVAewjps70+RERERERERERENIghSw0MWerAkGV66I5GPQA2A7gIwDEAybHML7JgwergnDkfNExzhlLKLqZSd8Z2775dlUqnlOSqKCEWtYLhtnNeQsylFMx0ImikBppgmFaxbXZPtuvCw6l1zzhZaplxTkbZ2Ap47Kix+KmTsrU3I1uLlsytWMFS0IeHZkXUjvXz7ftnhtW5f46IiIiIiIhoXFk2pC+Dxr6MhJM5CWcKCOeKEs6VEC5aCBctCRctRCwbDaaBrMdEymuohM+DpN+DVMCrEo0+JMN+lWxuRLItqNKmgel9MIuIaHwxZKmBIUsdGLJMH93RqAngYgCXADgBYEyvt6ehobG1q+vt3oaG5wCAXSo9nThw4Mb0iRMHa01firT40qsuWlSYs2ix8voCZnIgJqXChDSDl3zO60n0NotV8lqhSCK7ZPXBzKqLTmY714wpfKqHrYDdx4wFT5zUI1wKliwo36qsRh8emRVWO9bOs++b08R9k4iIiIiIaCLZCkjl4O/NSDiRk3A6j3C2KOF8EeG8hUjRklDJQrhkI1KyEbaci60QAsQYvzVRyhCkTANJU5A0DSQ9JpJeAwmvqVJOOJNo8KpU0I9EJKCSLY0qFWlA1pDxWwsiovMIQ5YaGLLUgSHL9NIdjRoANkGXD4sB6B/rPJuj0S2NM2a8RwwjrJQq5QcG/iu+e/ePMczOlZvf2ZxZvj5aap05VyyraKYGes95CTGXZYmZ7IuY2XTY9geyhTkLj2W6Nh5NrdsaV/6Gc7pOfz0m8584YWyJ68BlUfkWZTd68dgMHbjcO7dZ9Z/L9SIiIiIiIjrf5IrwxNMS6s9KJJ1HKFOQcK6ESKGEUFEHJuGShVDJRsSyEbYUwraNsIJ4R7tMgcqbBpKGgaRHkDRNJDwGUl5TJXwmkl4TmaKNxmIJoaIlblgTstx1sBFSkIbRP2pVckMZ9+IxkPSaKukzkfR5kPB7kWr0qmTIj0SkQaXagyrR4MMpFSuIiM4zDFlqYMhSB4Ys048TtGwAsBVAH4Desc7TF4k0t3Z2vt/0+zcCgFUoPNr/9NNfyPX29tSaXpmmpFdsnJNbvHKpFYy0mdn0gJFNnbNRJLUY6USjmRpogogqtcyIZzvXHU6t3XKiOGt+/lyvy+MnpGPPcR245EsSLd+iVIMXf5kRVjvWzLXvnd+ixvzaERERERERTVUlC0ZvRhr7Mwgn8xJxS3HlSwgXSggXbQk7o0sGR5ZYOiwZS1hhOWFFwgkrUh49iiTpNZH0e5D0e5Fs0GFFsqlBJVsbVTLox5jLVGcL8MTTEh7ISTiVRzirw6FwwbmUqh+vQtiyEQHEM9plClTONJAyDCQ8TjjjdcIZ9/EGvCrZ6EMypEuaJdqDKu0xwQOVRDRVMGSpgSFLHRiyTE/d0agAWA/gGdBlw+LjMd/W5ctfGGhtfYuIBJRtZ7K9vf/R98QTvx1u+lKkxZdeedHCQseiJRNdQswlhbzHTPQ2G8V8wApGErmFXYczqy86nlm2fgCmec7X56kemfXXY8aWWEq25kuyrPK2gFftnhFSO1Z12PcsblOxc75yRERERERE48BWQCKLhl7dtySUziOSrQhLCnpkR7hkDQkP3FJcoyyC5ZTd0qW3Em7ZLY+BpM9USa8HyYBHhyWNPiQjTlgy1cpuuWXO4hkJJ7ISyRQQyhYlkisiXCj3hAlb9tAwaqxlzgxRaUOQcEMoj35+9cgdXdJs8LkN65JmyZZGZKbSc0tE5w2GLDUwZKkDQ5bpywla1gC4FEAaQM1RJ/VqaG+f07R48QdNr7cLAEq53D29TzzxlWJq+JEquXnRpuzyC6PFtllzxbJKE1pCzGVbYiYHwmYmEbZ9gXxx5rwTma4NR1LrtsbsYMSaiFXaF5MZj+nAZUuuKCsqbwt41ONtIXXPqjn2PdEZ6sRErB8REREREVE6D29vRsIDWWe0hdu3pKLRu1OGK+Qc0I9Y+oD+WEZbZKvLYOk+JSrpHtB3R1uE/SrR1IBUG0dbnJZlQ3ozaOzXwVc4U0AkV5RQroRwwUKkZEmoaA32nwk5r2NYKWkc/VL1KCHD0D1nnHAm5TGR8Jkq6fMgFfAg0eBTyaATfLUFVTLkx4SerElEUx5DlhoYstSBIcv05gQtqwA8C0AewLgcnBfDMNpWrHiFLxJ5nYiYyrb70ydOfGlg374Hh7uPMk3JdG2YnV28stMKNU2KEmIuI5sOmMm+ZiglVqS1L7ts7aHUBZtPFOZFsxO1Tgd7pfXRI8aWnpRsyRaxqvLsLb9HPdUWVDtmRdQTQR+STQ0q0RpUKX7xJCIiIiKikSqUYMTTEhrIIpzKS3hIKS4L4ZIl4aKNsGUhUnJ6ljiluPyjXaZAFY3Khu4GEs7oh6TXRMI9yN7oU8mgH6nmBpVoC6pUwMu+IZNFvgQznpbQQAbhVGHIdhMpWk6/Gaui30y5341vtMsUqELVdpP0mEh4TZVySpolAh6VavQhEfKrZFMDUm0hlfR7MCEnUBLRpMOQpQaGLHVgyEIA0B2NroQOWiwAx8ZrvqE5c5aE58//kOHxLACAYibz8/iePbdYuVxuuPtMxhJig0pF05PobTLy2UarIZzKz196JLNq07HMio39yuubsDeTI/3S/PBhY3NPUrZmilg93JBu54tnwh0O7w6Fr2h0WK6l61PJpkYk24Mq6fPw7C4iIiIioqnKVkBfBo19ekSCWy4qnC8iUtAHvSNOuajBRu+2QthWEhz9UpVt6N8dSdMdjeD8BvGaKuU3kXD7lgT9SEYCuhRXKIA8y0VNT6k8fPG0hBNZCacLVf1mrHKvGXcUlO2UjQNk1HW9RVTGDWaGjIDSv5ETfg9STkmzRDigUs2NKtHaiIxpYHofTCQ6/zBkqYEhSx0YspCrOxpdDuAyAALgyHjN1/D5fG1dXVf7QqGrAMC2rGOpI0duTB4+/Pjp7ldRQmwebKvkSQ7EJ7yEmMu2YaYHQmY62aRMT6HYPieWWbHhUGrt1h6rqW1Cz6A6NiCRhw8bl5xMyuaChVnuD6Sx1NKt+OLp1tNNek0kPKZK+UwkAjqcSTlfPJPNjSrJL55EREREROMvmYOvV/fWCKdq9S0pH4iu7K0xpt8DTm+NwYPQpv49MHiylluKK+jXjc/d3hr8PUBnm62AgQwaejMSSeiSZqFsUSLuPlGssU84AWJo9EtVtiFIu318THGDmfI+EfA6+4QuaZZobVSpcAA5BohEkxZDlhoYstSBIQtV6o5GlwJ4DgAPgEPjOe/IwoVrgrNnf8AwzXallF1Mpb4f2737f1SpNGwoUS4htmKpFWpqN7OZSVNCzCW5rM+TiLfAtk073NyfiV5wKHPBxSdyi1emJ3rdXFVnroUzBacucvmLZ6RkIVRxVtB4n7mmzwiqGOrvnLmWavCqRNCvGx228cw1IiIiIpom8iWY8ZSE+7MIp/MSyhQQyZVkaN8SqyIsGb+SSkMODFeObPd7kPS7I9udviUc2U7no5IFI5aW4EAW5X4zJQnlS4gU9W/kUMke7DczeFGQwOiXqkpmZWUJA0nTRMprqITPg8FwpsGnkiFd9jvZHlJJlsIjOicYstTAkKUODFmoWnc0uhjAcwEEABwYz3l7GhuDbcuXv93T0PBsALBLpacH9u//98zJk6cNdEqhZl9m1UUL83MX6xJiqYG4FAv58Vy3MbNKhifRFzGy6aDd0JjNz11yJNO14Xh67db4RJYSG4s6azCHbCegGecazIPDtb1uSTPd6DAV8iPJGsxERERENJEsGxJ3DtY6Z9KXvzOXEC7ag2FJudG7QkQpaRj9Ugebgw+OLHHDkoq+JckGn0oEfUixRyPR+MgW4ImnJTyQlXDKLWlWRLhQckrv2RIpOaX3LOf3sVPSzDPaZQpU1jROLb3nNVXS60HK70GiwauSDV598mJzA5JtQZX2mAxHierAkKUGhix1YMhCtXRHowuhR7SEAOwf7/k3R6NbGmfMeI8YRlgpVcz39/9XfM+ebpxhh8zPXRLJdF0YLbbNngfbsiZVCTGXUjAyyUYz1d8EMexS66xYpuvCQ6m1W3tKbbOnxY+adB7e3oz+4pnOI5zR9Z6dEgbOWXlVZwSN0xfPpPPlM+Gp+KHp8+hwpqF8Vh6/eBIRERHRELYCkjkEetMSTuTKPSHcE4yKJX2CkXMANWKpwdJDwdGX4lLKEKSHlOY19XdZr6lSPs9gaV637FCypUElmxqR5ehvoqlhFO8tIctGZLzeW4zyyYsJj6ErS/g8g/1mEkEfkuGASrU2qgTfW2gaY8hSA0OWOjBkoeF0R6PzoEe0NAN4erzn729qamlZuvT9pt+/AQCsQuGR/r17v5Dr64ud7n5ToYSYSwo5ryfR2yylktcKRhK5RSsOpy+4+Hh22bpJub4TyVZAIouGvoyEEjkJp3V96VC+hIhT0ixUtOGeFRSu+FEbAmSUXwNP+VE7WDLBp88KSgYqwplIg27GGWngF08iIiKiyWzI2ebO98pzdLY5T/ohonFh2ZDeDBr7nX4z2cqy37VKCjrvY0pJ4+iXWv8oubagSgb9KI7fIyeaEAxZamDIUgeGLHQ63dFoB3TQ0gpgHzD+jQtbu7peFGhpeYuI+JVtp7Px+H/0Pfnk3We6X0UJscXK62uYlCXEXJYlZqo/YmaSIdvXkCvOnn8ivWLjkfTarTG7Icg37zFwyzP0ZxBOlkuaRfIlhJzyDJFhvniOpTxDya2j6w7bdoZrp7wmEn4Pkn4PUg0+lQj5kYwEVJJfPIkml5IFI12AL1MQX64EX64If6Ek/qIFX8GCv2TBV7TEb9nwl2z4LBt+S8Fn2fDZtvgtBb+t4LMV/LYNn9L/99uATyn4ANheE3Gfibjfo2INPsRDfhVrbkBsVkTF2kMqxbCWiKh++RLMowPSEk9JeyIn7ek82nNFactbaC+W0F6y0TqOfROGlK/1GOWwxDnImHTL17Y2qlSDj+VriWjiuf2eBrIIOWW/y/1mLKffjFXRb2Yc+z15DPT6TMR8HsQDXhVr9CEeCahYW1DFO5pUnO+TNIkxZKmBIUsdGLLQmXRHo7Ohg5aZAPbiLAQtDe3tc5oWL/6Q6fUuB4BSLrej94knvlpMnXmEytASYrblSfZPvhJiFYxMqsFM9jUBglJze2922dpD6TVbThbmLMxN9LpNJ7kiPEP7zegzgpxGoxHni2e5drZCxPni6R3tMgUqb7hnAwmSZrnRaMJnIuXXpSASjT4kg+WzG1NsNErTga2AQgmeVB7+XFEHH/mi+AsW/AULvmIJ/pItvpINX8mCvyL08Fs2fLZygg8deOjww/nrBCA+hXIYMpYzlceDQBU8JmIeQ/8I9XtUrMGLeNAJYmaEVXxWWCVMY/w/c4mIJqt0Ht5jCWmNp6U9mZO2TAHtuaK0F0poK1hoL9los2y0jHwUs7INGexjMHhWttcsN3oPeJFs0N+/UpEGlWhrVMlQAHkG4UQ03aTy8MXTEk5kyyXNcrqyRKigR81ESjZCzm/ksO38Tq6npJkpqt9jIu51gxiPDmLCARVrbVSxOU0qHg6wdxRNCIYsNTBkqQNDFhqJ7mh0BnTQMge6dNi4v+GIYRhtK1a80heJvFZETGXbvekTJ748sG/fzjPdV5mmZJZfODu7ZOWkLyHmkmLBYyZ6m4xCrsFqDCdyC5cfyay66Hima0M/THOiV49qsBWQ1l88I05JMz1cu6iHaxcqhms7ZwVFLBshW5eeGGUtXcAQlTZk+IMDfi8SAY9KBf1IhgMq0dygUq1BpHlwgMbKsiGZArzpgvhzRfjzJfjyJfEXSvAVLfiLVjn4sCz4S07IoQMQ8dn2YNhRHvWhykGHE4b4lIJfAb6x7CdjIVBFERREkBcgbzj/NgQFQ//V/zb0/01DOX+RNw0UTAMFj4G8x0Dea6qC10S+ZMObyklbpoj2fFHaChbaCxbaShbabSWRka2ZKnkM/SPU64yICXgRC/oRbwqo2Iywis+JqH6WmSGiqSCRhf9YQtp609KezEtbVgcobQUL7UV9abOVNI1sbsO/P0YCqjcSUAPNjSrZ2ogMw2oiorPHVkCfLmkWTuQkksiiNVWQtlwR7fmStBVKaC85IflIR8oYopLue7zPg1jAo+INPsTCfhVvcYKY5kZkz/Zjo2mHIUsNDFnqwJCFRqo7Gm0D8DwA8wA8hbMQtABAqKMjGp4378OGxzMPAIrp9M/ie/bcYuXzZywFpkuIbVqQn7tkyaQvIeaybZip/rCZTkZsn69QnDH3RKZrw5HU+mf22MGINdGrR2Nn2ZC+DBr7sxJK5iSSziOcK0koX0TEraVbdHrNuEO2bYWwrSQ4+qUq2wlmhtQE95i634wTziQbvCoZLJc0SwT9KDCcmdzyJZiZPHyZ4tDgo2jBV3RKXJWc0R3uX8vWoYZli89W8Nn2kNDDDT70qA/o8EMHH6MfuTU2yhagIE7IIeXQww0+qsOPvCmqYOjAI+/RAUjBYyLvMXTo4TWR93lQ8JmqEPAiH/Ai3+hVhUYfiuc6pEjn4T064BxodM/ULklbvqQPMpYstFsKzSM7U1vZHgO9Hn2gMeZ3zgh0DjTG2kIq1tGk+vwe8POEiM6avjQajiWkvS8jbam8tGcK5YNrRQttJRvttpLQSObFkX5EROcfWwE9SQmfTEpbfxbtqby0Zwtoy5ekvWChrWjpMGakpR5FVMZrIObR5Xljfq+KN3oRC/lVvLkRsVkRO9bGEw+pPgxZamDIUgeGLFSP7mi0BTpoWQBdOuysHLQxfD5f24oV1/iCwSsBwLaso6nDhz+fPHLk8ZHcPz93SSSzfP2SYvuc+bBty0z1x8WevCXEXEY27TeTfS2ilJTCLf3ZZWsPptZsOVGYF+VZGtNQoQQjnpZQfxbhdHW/GR3O6Dq6FsIl5YQzuqSZf7TLFKiiYSBpiu434zGQ8OhRM4P9ZgIelWyobNgaUsnpfADXVkDG7e1R1L098iXRJa70aA9fyQk+nN4eFSWu4LeU+CtGfAwGH0NGeSj4bB1++CdqtAegSoYe6TE4yqMy+HADEcNAwRTkDVF6lIfo4MPUIz0qg4+Cz4O8z0Te51GFBi/yAa8qBH3I+70oTfcfRLkiPMcGpCWWlvZEdrBkzmDPgaIumdM6su1BKdNAn8fQP0IramTHwgEVbwuq2FzWyCaiGmwFxFISOpGQ9v4s2qoOig0GKCPtdSdQWScU1gfFhvasirNnFRHR9OWOijmeMNr7M2hLVn7mlJwgRof2IzoZUaDyHhMxr4G41+N85nj1Z05TA+Izwyo2K6IS/MwhB0OWGhiy1IEhC9WrOxptgi4dtgQ6aDlrB2UiCxeuDc2efZ2YZrtSyi4kk9+N7979HWVZZzyg65YQyy1eGS2Fm2YYuUzCzKSmxjZeKhmeRG+zkc822oFgKj9/6ZHMig3H06sv7lNe3/R+06IzSufhjaclnMhJOJVHOFvQwcyQfjNOHV3LRsiyEbF0SbNR16kTUVk3mHHKmiU8JlJeQyV8HiT9HqTcfjNhv0o2NyLZFlTps3UWaqEEI1OAP1MUX94JPgqW+AoW/MUS/EUbvpIl7kiPwdEeloLPtsVnVZa4sqtKXGFI+OEfS4PIsRKoIaM8RFAwMDj6I++WtzLECT6MocGHxxn54TVV3mNCBx869MgHPCgEvMg3+lQh6EOBJakmn0IJxvGENPekpD2RlfZ0AYOlGYrlg59tI+0/Y4ga8Lo1sk3EAt5yaYbWoIp1NKkYa2QTnT8sG3IiKZEe56zidF7as8XywaySPXhW8UjLu6Q8hhOg6INZ8UYfYiG/irU0qviciIq1BFnehYiIxmYgi8CxAWnry0hbMiftYynPK1BFs6r8pB49iVhTg4rPCKnY7Iga4G+haYEhSw0MWerAkIVGozsajQB4NoBOnOWgxRsMBluXLXunp6HhWQBgF4tPDRw4cGPm5MnDI7m/FYx406su0iXEfIGgmeqPTfoSYi6lYKYTQSM10ATTtIrtHSczy9cfTq/d2lNqmVGc6NWj84etgEQWDb0Z3egwU9D9ZnIlhIslp9+MjXDJKWvmBDMhWyE08uaz1ZQabEbr9pwxkfQaSHhNlTIEJbfHh61ksORVRTNz3yn9PZxSVxPX1FxZIsgbqAo+avX4MFBwSlzlTbe8lTH4t+AEH3mviYLfg7zfowp+D/INPpVv9KLQ4EORZ13RmVg25ERCmk4mpW0gi/ZxqJHNg6hEU0DJgnEsIc09SWkbyEl7Oj8YwrYXrcGzgccthJ0TUfFIA6bG92siIjrvpfLwHRuQ1tOX55WWkc1NWW55Xp/zHTjgVfGgD7FIQMXaQyre0aR6fR4GMVMcQ5YaGLLUgSELjVZ3NBqCDlq6ADwNnN2zW1uWLn1GQ3v7u8UwQkqpQr6//9b4nj3/hxHuxPmOxeFM14XRqVZCzCX5rM+T6G0Wq+S1Qs0D2ejqA+nVF5/MRVenJnrdaPoqWTDiaQkOZBFK5iXilDQL50sIF0oIF20Jl6xyrxn3ojCysiLjQaB0Q3NnlEdV+DHY02NwxIehnFEfg6M9dJmrit4eOvhQeb8XhYAHhUafyjf6kOcXa5qKzkKN7OxgEMNyQETjLl+CeXRAWuIpaU+4AUpJ2vOl8v5aGsdygnMiqjfoB0/uISKi88o4l+e1TQP9HkOfjFDxear7JAZVvIPleSc7hiw1MGSpA0MWGovuaDQI4DIAKwDsw1kOWvzNza0t0eh1pt+/HgCsQuHhvqee+kK+vz8+kvsr05TMsvWzcktWLdUlxLIJM5OcWtu9VTI8yf6IkU2HbH9DptCx6HhmxYYjqTVbepW/gR8ENCXkivDofjMSSecRyhQknCshUigh5JQ0CysF0w0/TFFuX4+CO+LDYyDvMQeDj4LPRL4y+Aj6Vb7BiyIb4xKN3VmokX3GxtazI2qAQQxNN9kCPEcGpC1eeeZtUe9nBWf0iWWjZWSjSJXtnnnrNRHzexAPeFQs6HcO+IRUrKNJ9U3nvmpERESnUyjBOJaQlpguz9uWLqA9W9Qjwgv6xAa3PO+ISm+bovo97shQ53O50Yd4OKBirY0qNqdJxVmed8IwZKmBIUsdGLLQWHVHow0AngXgAuig5ayXCmjt6npxoKXlWhHxKdtOZ+Pxr/U9+eTvR3p/Kxjxpldump+fF41OuRJiLqVgZJKNZqq/CWKoUsvMeGb5ukPptc84UZzRwQ9lIiI658azRjagSs6IGNbIpvNCMgff0QFp701LezIvbVnnjFmngXx70UKbraRpZHNTJU9VDfmAF7GgH/GmgIrNCKv4nIjq5/5BRER0dlk25Lguz9s+4AQxuYrvwEULbZaNdgXxjmR+hqik+xnv8yAW8JRLdLY4QUxzI8vzngUMWWpgyFIHhiw0Hrqj0QCAZwJYC+AgcPbf8BtnzJgbWbToQ6bX2wkApVzuj72PP/7VYjo94vJZgyXE2mbPg1L2VCsh5pJC3uNJ9DZLseC3gpFkblHXofTqi49nO9cmYI66lzkREdG4G1mNbDSP8Ex91simSaEvjYZjCWnvy0hbKi/tmUK591FRn+XabisJjWReIxnpNSusEhypSURENDXYCjipy/O292fQns5LW9btk+icbOGU5/WPZH4iKuN1T0ZyRsQ0eBEL+VW8pRGxWRE73hpEmqPC68KQpQaGLHVgyELjpTsa9UEHLesBHAKQOdvLFNM021aseJUvHP5bETGUbfemjx//4sD+/btGOo/BEmKLV0ZLkeaZU7KEmMu2xEz2h81MMmz7ArnirPknMssvPJpeszluhZtZ+5OIiKYE1simycJWQDyN4ImE0d6XOaVn0WCAotTIeo0JVNYp38WeRURERDTIVkCv/s7R5nznaMsW0Z4rSXuxXJ63rY7yvLnB0mT6O0e8wYtY0K/izY2IzQyr2MywSvI7xyCGLDUwZKkDQxYaT93RqBfAVgAbABwBkD4Xyw11dHSG5837kOHxzAWAYjr9f/Hdu79pFQojLpt1agmxgZgU81OrhFgFI5MKmKn+ZlFKSuHmgdzilYfSqy8+mYuuHvFIHyIiosmqUIJxPCHNPbpGdnu6gLacc0ZgsXzwuw0Qz0jmxxrZ04+tgBMJiejyHmhL5aU9W9QBihvm1XNWqSEq7Za4GxyB4kM87Fex5kbEZ0fsWFvw7J+EREREROev/gwajiWktS8j7SldnrfN7d9WtPWIGFtJeCTzEqiiaVSc/OFV8YAXsaBPl+edGdbleafJ6FmGLDUwZKkDQxYab93RqAfAFgCbABwDkDwXyzV9Pl/bihVv8gaDVwCAbVlHkocP35g6cuTJeuaTn7MwnFmxUZcQg1Jmsj82FUuIDSqVDE+yr8nIZYK2P5AtzFpwPLts3bHUuq0xOxhho1MiIjpvWTbkhK6R3TaQRXuqIINBTKGkf4SWbLQpiG8k82ON7KmjZME4npCmnpRTHz2PcoBiDZ4N2j7SEM4QlRgsS+cchGj0IhYOqFhLo4rPaVLxpgbkzvbjIiIiIjoTpzxvWzzt9EksoC1XkvbCkPK80jyyuSnLYyDucb4D+TyINbjleRtUvD2kYnMiqu88KM/LkKUGhix1YMhCZ0N3NGoCuATAxQBOADhn21Zk4cJ1oTlzPiCG0aqUsgvJ5Hfiu3d/V1nWiAMFZZqS6Vw7M7dk9dIpX0LMpRSMTKrBTPU3AxAr3NKX7VxzKLNy48nc4pXnZMQRERHRZGMroEfXyG7rz55SDqqtokZ2YCTzc2tke6oOxoec0gyz9GgG1sgeg0IJxtEBaY2lpC2Rk/a020C+hPaCc+CgpMvJjaAxnVKmoN8z2EBeh2eNPsTCARVvDapYR5OKB/0onv1HRkRERHRu5IrwHB2Q1niN71NFS4+KsWy01FGet8/rjoqp6pPY5vRJDHgndXlehiw1MGSpA0MWOlucoGUTgM0AYgD6z9WyvcFgqHXZsnd6GhouBQC7WHxy4MCBGzMnTx6pZz5WMOJNr9g4Pz9/6XlRQmxQqWh6En0RI5dptAON2cKcBcczyy88lr7gkjhHtxAREQ1lK6Avg8bjCaO9P4O2pA5ixlIjO+8xEfMaiHs9Tl8Or+7L0dSA+Mywis2KqMR0DGKyBXiOOmdeJtwzL50SGAVn9Illo7mOH/y9g8+zqX/wN7pnXgZVbE6T6pvkP/iJiIiIJkShBONYQlpiujxvW7qA9mz5xJb2Urk87whObBksz1sOYirK87YF9cjgkH/CyvMyZKmBIUsdGLLQ2dQdjRoANkKXD+sF0Hcul9/S2XlpQ1vbu8QwgkqpQr6//5vxPXt+ijp3/PycheFM14YlxfY588+LEmIupWBkko1maiACQKym1t7s0jWH0ys39eQXdXF0CxERUR3OQo3suHdwhIUOYoJ+xJoaVGwq1shO5nTpit6MtFeVrnBHDLXVUbqi5JRui3udZq5ODfF4pEHFZoRUbHZE9Z8HpSuIiIiIJi3LhhzX5Xl1idYC2nNFtOeL0lZw+iRaNtoVxDuS+Rmiks7JSLpPolfFGr2Ih3SJ1ljH2SvRypClBoYsdWDIQmebE7SsA/BM6NEsvedy+f7m5raWpUuvM32+dQBgFQoP9T311Bfy/f11rYcSQWb5+lnnVQmxClIsmGayv8nIZxvtQGO60LHoeGbZ+mPpNZvjdkOQHzBERETj4Hytkd2fQcOxAWnry0h7Mi9tzkgft+SEO9JnpAFTwXlcMZ+nHKCEfCre1IDYzLCKz5piARMRERHRdGUr4KQuz9ven0F7Oi9tWbdPouV8V9Tlef0jmZ8hKu32SfR6EA/ok5FiIb+Kt+jyvPHW+svzMmSpgSFLHRiy0LnQHY0KgLUALgWQhC4fdu6ISFtX10v8zc1vEhGfsu10Nhb7at9TT/2h3llZjSFPeuVFC9wSYkZ6IG4U8udPo9Py6JYmiCirqa0vu/SCw+lVF53ML1iWmejVIyIiOt9NphrZtgLiaQRP6FJp7am8tGUqzk4sOeujlDSO5LEJVM4pExHzuSN0fLpUWrMToMwIq+R0LJVGRERENF3ZCujV3znb+pzvnNnimMrz5jzOiGefM+q5wYtY0OmTODOsYjOHfudkyFIDQ5Y6MGShc8UJWlYDeBaAHIAT53odGmfOnNu0cOGHDK+3EwBK2ezve5944mvFdLru0lj52QtCmRUbo7qEGKBLiFnnVT8TPbqlzxndEkrl5y46ll2+/nhqzZZe5W/ghw4REdEEOZs1sk0DmaIucdY2irMKdYDiKQcoYb+KNTciPjtix1oakWGAQkRERESjcRbK88a8JuINXiQbfOrE36yxXsGQpYwhSx0YstC51h2NroIOWooAjp/r5Ytpmm0rVrzGFw6/WkQMZVnx1PHjX0wcOPBQvfNSIsguWzcrG71gqRVuniH5bPJ8KiE2SCmY6UTQSA00wTDsUlN7b7ZzzeH06otPFuZFsxO9ekRERHSq8ayRbYhKeJzRJz4TMb9XxRu9iIV1fez4nLNXH5uIiIiIaMRG2wfQa6qTb91amsOQpYwhSx0YstBE6I5GuwBcBkABODoR6xCaO7czPG/ehw3T7ACAYjr9k/ju3bdahUKh3nnpEmKb5ufndy49L0uIVZBiwWMmepuMQj5gNwTT+blLjmWWrz+evuASjm4hIiKaYmrVyC7aaGz0Ih4OqHhrUMXmNKnekB91fz8iIiIiIpqMsgV4jjp9EhM5aS9aWGAIii9cab2RIUsZQ5Y6MGShidIdjXYCeDYAE8DhiVgH0+/3t3V1vdkbDL4YAOxS6Ujy8OEbU0ePPjma+ekSYhuWFNs7FgDnZwmxQbYNM5N0R7dYpZYZvdmlaw6nL7ikp9CxmKNbiIiIiIiIiIhoKmBPlhoYstSBIQtNpO5odAmA5wDwAzg4UevRtGjR+uDs2deJYbQqpexCMvk/8b/+9bvKtut+Yy2XEFsdLUVaZhm5bNLMJAfOxnpPFlLIe8xEb7NRLPithlC6MC96JNO1/kT6gs29yuub3m+yREREREREREQ0mTFkqYEhSx0YstBE645GFwJ4LoAggP0TtR7eUCjcumzZuzyBwDMAwCoWnxjYv//GbE/PqMqZDZYQm7c0agcawmZqIHa+lhAbZNsw0wMhI52IwPDo0S2daw+nL7jkZGHOwvP7sRMRERERERER0VTEkKUGhix1YMhCk0F3NDofOmiJANg3kevS0tn5rIa2tneKYQSVUoVcX98tvXv2/HS08yvMmhdMr9wUnRYlxCpIIef1JPqapFjwW42hVH7e0qPZrguPp1df3MfRLURERERERERENEkwZKmBIUsdGLLQZNEdjc6FDlpaoIOWCds5Ay0t7c3R6HWmz7cWAKx8/s99Tz31pfzAQO9o5qdEkO1cOzMbXb3UirTOlEIubaYT/eO60pOVbcNMDYTNTDKiTLNUapkZyyxbeyR9weaTxVnz8xO9ekRERERERERENK0xZKmBIUsdGLLQZNIdjc6GDlpmAtiLCQxaICJtXV1X+JubrxERn7LtVCYW+2r/U0/9cbSztAJBT2bVpnm5+Z1Lp00JsQqSz3k9yd5mKRZ9VmMomV+w7GhmxYbjmRUb+zm6hYiIiIiIiIiIJgBDlhoYstSBIQtNNt3R6EwAzwMwC8DTACb0za1x5sx5TQsXftjweqMAUMpm744//vh/lDKZ9GjnWZg1L5hesTFanDF3WpUQG2RbYqYGQmYmGVamt1RsnRXLLl93OH3B5p7ijI7CRK8eERERERERERFNGwxZamDIUgeGLDQZdUej7dBBy1wAT2GCgxbxeDxtK1a8xhcKvUpEDGVZsdTx419IHDjwyGjnOa1LiFWQfNbnSfQ1SanotYLhVG7BsiPZFRuPp1du6odpTvTqERERERERERHR+Y0hSw0MWerAkIUmq+5otBW6dNgC6NJhEz7SIzx37vLQvHkfMkxzDgAU0ukfx3fvvs0uFEY9+qKihFhU+RvCRnogPp1KiA2yLTGTA2Ezkwwrr69QbJsdyy5bdyS1ZnNPqW02R7cQEREREREREdHZwJClBoYsdWDIQpNZdzTaDB20LIYOWkoTukIATL/f39bVda03GLwcAOxS6VDy8OEbU0eP7h3LfAuz5gUzXRuXFGbOXQhMwxJiFSSX9XmSvc1ilbxWsGkgt3D5kcyKDSczXRs4uoWIiIiIiIiIiMYTQ5YaGLLUgSELTXbd0WgEOmiJYpIELQDQtHjxhuCsWe8Xw2hRSlmFROKO+O7d31e2Peo3YyWC7NI1M7JLL1hqRVpnTdcSYoMsS8xUf9jMpELK6ysW2+f0ZJatO5Jeu7Wn1DKjONGrR0REREREREREUx5DlhoYstSBIQtNBd3RaBjAZQCWA3gawKQ4wO4NhcKty5a92xMIbAUAq1h8fGDfvhuzsdixscy3soSYHWiImKlE3CjksuOz1lOT5DJ+T6K3GbZl2qGmRG7hisOZlRtOZpatH+DoFiIiIiIiIqJzwgPAX3HxAfACMJzb8wASAJKYJCfJEo0AQ5YaGLLUgSELTRXd0WgQwLMBrIAOWiZNn46Wzs7LGtra3imG0aiUyuf6+r7Ru2fPz8c638KMucHMyo2LdQkxkelcQmyQHt0SMTPJkO0L5Itts3uyXRceSV+wOcbRLZOSAcCs86/7b5cNQDl/begvPqrieqvGNJWX6uuJiIiIiIioNi/K4YkbpHid2wT6WEwBOkzJAOiDPq6Ygf4tNxfAbAAR6EAmBx26JMDfYzR5MWSpgSFLHRiy0FTSHY02QI9oWQVgP/SH+qQQaGlpb45GP2D6fGsAwMrnd/Y99dSX8gMDfWOZrxJBNnpBe7ZzTSdLiA1lZNN+M9nXDNs27VBTIrt45aHMig0ns51rExzdUhfB0HBjJAFIrTCkFjcAsSv+XfnXgt6Pi9Bf1IvO/wvObQb0F3MPymdImVV/PRXrY1Q9nurrR7phnCmwsUYwDYMdIiIiIiKabCrDE/ffHuc2BT36JO9c0gD6UQ5Rss7fDIDstvXemic6bt9VDEAftG4HMB/ALABh6N9laejAJQ3+VqLJgyFLDQxZ6sCQhaaa7mg0AOBSAGsAHIT+kJ8cRKRtxYq/8Tc1vVFEvMq2k5menq/07917z1hnbQWCnszKjfNyC5axhFg1q2R4kv0RI5sK2r5Arjijoye7fP3R1JotPVZT2/k0PNkNCc4UegwXjlTPy/0ArAwOhvtbQjkIqb6UKqaxqv592r/j8eVl+66iG6pUPuax/NsNdrzQPzqqQ53qYOd0oc7pgqjK1wCoHc6cLsg5U9Azvb/gEBERERFNP4JycFIZprghio2hJ7YloI8JDqAcoAz+3bbeOy6/p7fvKgbx/7P359GR5ed55/m9N/YVgSX3PW8Way9WsVhcKimSSVE7IYpkkaJIta1299iyLall9ahHntPudp8ee8o+3ZY90nSPx/ZMS6OiluImhURR1pKkyCyuYlEUqWKxKnLDlokMbBEIxH5/88cvogKJQi6RlcBFIJ7POTgAIjIDb1YBiBv3ue/7wjj2RPZRYA+Q7tS7PnTRaxgJikKWTShk6YNCFhlEec+LAd8HPMpOC1qA5L59R0eOHfslNxw+CdCsVs8ufve7/75Vra691sfWCLGbc9dW46HV5Zzj+247k1uunnhgeu2BN85XX/doeTvL4Mahx626RZybPO7NOkK6990oCGnSR/jBhsDkVx6LDPeT5Qbrgp27FeqE6AU73fcbQ53unONbhTrrP98Y5Gy0MaTppztns1Ft+j4REREREdk6Lq8OUaLY1wvdY/H6urcSdpzXKhsCFGyIEsi5hKefb2awJ7X3YEOXcWzo4ndqLXXqFNkuClk2oZClDwpZZFDlPS8KnAbeAMxgr3rYMZxwODxx//0fjqTTTzmO4/rtdrFy5cq/LV269K3X+tivjBA79fCp9sj4fo0Q20S75YZLS1m3tpb2o/Fqc++h+bV7H5utvP50sZ3Jda/G6Sf82Pj+pl+dVwciGz/ujsja+P52w5BNb1MYsrs9/XzzTsKbm93eHcV2o1AnQi+8Wd9JdaOwB3pB4c0Cnn736NxsVJu+50VERERkt3B59VL5GL0LqNr09qHUsefzlrlxiLLjTxZ3LmAboRe6HANyQAp7vF/G/jtrAZUow0EhyyYUsvRBIYsMsrznRYAngTcCs9gDix0lc/jwfelDh/6JGwodAGisrv7+wgsv/KbfbL7mJe1+LBGqPPDE4dqxe0+ZWCLjrpUX3Xp1R3X1vGaO4xjHcXBc1745jnFdF8dxcVzX3ud0Pncc47ivfIzjuABupRwLlRbTjvGd1sj4au3kg1er3sNLjUMnytz5vpA7CUG6I7LUeSQDY12wczdCne7H68ewbQx1un924xi4zUKd7m03sj7oWR/ObNaF08+oNh10i4iIiMidCPHqUV7dEKV7jNp9zVmlN8prlVeP86rtxovsOq8/ctiT3vuwnS45II59TV3qvDWCqVB2KYUsm1DI0geFLDLo8p4XBt4CvAm4gr3KYUcJxePx8fvu+3uRZPKHAfxW63JpaurfVObmzt+Nx29MHEiuPfDEycbew0dx3VCovFx02q3t3UWyPuBwu+GH6+A4IRzXuUkYYgORmzHGxxiD8X3Hfuzj+z4Y4/i+j++3Hb/dctqtltNqtWg3W06r1XRazZbTbrUdv+3TbvlOo054dSXn1NZShELldjJzsXHYe3nxhz96uXrPI3W2YF+IiPSv88LqboY668exbRbqdEexrf+6m3XwrA96NrOxe2cVe2Xh7gq/RUR2JhfIYk/EufT2yTU7H7fWfawLXkRkq4R5dRdK91hzfYhSpxeiLLFumTy9EKW+G0OUfj39fDMEjGFPgu8HDmN/10fp7ZUpY3/Hi9wphSybUMjSB4UsshvkPS8EvLnzdg37Pb3jjJw48cbUvn2/4LhuzhjTbpRKH1t44YVPGN9/zb/ANx0htlZeYeMvufXdH5uHITb0cN0QOI5xHRe6n9+C77dt8GF8MAbfb2OMscGIb/DbLafdbjvtVtMGIs0m7VbbbTZb+O220275+G3fadlgxGk120677TutRpt2y37eavpus9F2Wk3faTV9p1FrO3f2ezyDbUV2gHngBeDSZKGweCcPJiKDrTOm4HYDm9sJfSLYUQdjQAL7AnAF+yJQJ/dERO6OBHbETAZ78rKE7W6vYMfMJDtvm+09W6+7167FqwOZ7nsREbC/QzZ2okTW3d+dglDHBiVL2GPAjQFK9Vcei9S3r+zd4+nnmxHsDpdx4CBwCBuyR+jtodExt/RLIcsmFLL0QSGL7BZ5z3OxY8OeBBawVw/vONFMJjt6zz3/KByPPwnQbja/u3Lhwq9Wi8W5u/H43RFi9aOv89qJ5IhjzPVPDsaYTmeI7xjfv/5zYzC+cdrtJu1Wy2k3m0673XaaDRuKtFtt2m1/XXdIJwRptp1uCNJu+bRbvSCkWe+8b/h3GIZstTA2bMliD8QuAC8D05OFgq6EEZE71unIGQf2Yq+4O4i96s5BXS4iIndifbdKFDuffxF7/HYVmP+VxyLX7WnshOjRdW+xTT6PY8OYdOf9+s7HbjCznmHzIGZ9ULMjD3xF5JY2Wyq/MUTpdqJUsMdz60OUV97/ymMRvZ7cBk8/34xhj7knsMfc+7ABfAj7/6Lb6aIT53IzClk2oZClDwpZZDfpBC2PAW/DHuzs2K6E0de97kxifPxnHcdJGGNqtcXF/7T44ot/crcevzFxIFk/7E3YcVrru0LWByKd8KPVbDuNhu+0Gr7bag7zk0kW+8TqYEfPfRfb3bIUaFUisis8/XwziQ1c9gEnUJeLiMjtuFG3yhS2G3nhbu+761wlvTGQ2Xjleopet0z3JOz6jpmN43A3G1u2/uNhPgYX2S7rQ9f1+1C6o2K7XW3dnSglejtRNu5Dqf7KYxF1ue1ATz/fTGBf108AR7DH3xns/+M17P/XVRSGy/UUsmxCIUsfFLLIbpP3PAd4FPg+7NUKxUALuon42Nie3MmT/yQUjT4E0KrXv7b00ku/1iiVlgMubdhFsE+w3e6WAra7ZWayUNCBtIi8ZupyERG5ob67VYL29PPNMJt3yqz/uNslk8QGR2Gu75TZuO+rzc07ZRTKi7yay+adKOHO/YZeF0p3rNQS9thrYydK9W4HuBKMp59vpuiFLsc679Odu1ex3wc76nlFAqGQZRMKWfqgkEV2o07Q8jDwDuxB0nywFd2E4zjj99//3tjIyN9xHCdsfL+8du3ary8XCl8KujQB7JWTE9gD8qvY3S0XJwuFHbn3R0QGU6fLZQ+2y+Uk6nIRkeGy7d0qQeoE7TcKY7ofJ+gFM91QZv0Ys+5eGYfeMu0bdcl030QGXfdnZ+Ni+e5S+W6I0sAGtLcKUXQidch0RkhmsK/x9wBHscfdKez3Txn7faOLnYaPQpZNKGTpg0IW2c3ynvcg8E7sgdbVYKu5udS+fUezx479t244fAKgWa3++eJ3v/sfWtXqWtC1CWBf0HZ3tyxjO1sKwKy6W0TkbrpJl4uLfeG3jF74ichg26xbZQG4yA7tVglS53lh/bLtzYKZBL29MglePb6sOw6py+fVYczG9yLbLcSrR/PFOvc52O/L7lL5Gr19KKu8epxX7Vceiwz3CT+5pU7okqMXuhzrfJ7EnnDvhi61YCqUbaSQZRMKWfqgkEV2u7zn3Y/taPGBu7Jcfqu44XB4/P77PxJJp9/vOI7rt9vXKnNzv1q6fPnbQdcm18lhn4B97FWW3d0t+h0qInddZ670xl0uSdTlIiKD5UbdKpex3SqLu6lbJUidk4Y32yvT/Xj9CLMY148vi7zqgW34stnosu7Hw31yRW5HmFd3oXTH5XU7srqjvLohyjJ2lNPGEKWuEEXutk6oPYp9vb8P2+kyAsSxv+dKnbdGUDXKllHIsgmFLH1QyCLDIO95r8N2tLjATLDV3Frm8OH704cO/RM3FNpvjDHNSuXTCy+88Ft+s9kMuja5ThR7tUsK+3v0JeA8trtFJwlE5K7rvPAbo9flcgh1uYjIzqRulQHy9PPNbihzo2Amhj3mTdELZbpdMt1gZn2nzM1GmHU/10ms3Wd9x1U3TFkf2DWxJ6cb2OBkBTvOa7Ol8vXtK1tkc52dW2PYE/D7gSPY57Yo9vu4G7qo+2/wKWTZhEKWPihkkWGR9zwPeBf2yfBywOXcUjgeT4zdd99/FUkmfxDAb7Uulaam/k1lbu5C0LXJqzj0drf42CCv291SDrIwEdndbtLl0sQe362gLhcR2T4bu1VWsJ3k6lbZZZ5+vrl+rNPGYKb7ebdLJo29Cnz9+LLu2/oTMutDmc06ZfS9E7zNlspH6f1/bNLrRKnQG+e1cR/K2q88FtEFhDJwOoH0OPa1/0HsBU9Z7O+z7h6gMvp9NYgUsmxCIUsfFLLIMMl73gls0JIALgVczm0ZOXnyidTevT/vuG7OGNNqlErPLLzwwqeM7+uX/s60vrtlmV53y5y6W0RkK6nLRUQCsL5bJYb9HdPtVrmC7VbRfkHpPkdt1h2zca9Mt1smwfWjy9bvlemexPHZPIzRXpk743D9/4/uW/e/e/e/d3exfIne2NLNQhT995dd7+nnmzHsyfkJ7PH3PuzzYgj7s9ANXXT+ZudTyLIJhSx9UMgiwybveUeB78deUXUx2GpuTzSTyY7ec8/PhePxtwC0m80XVs6f/zfVhYWrQdcmN+RgZ7mOY1+MrN/dshpkYSIyHNTlIiJbpNutksWeNFrBHudMYbtVFnRyQl6rzl6ZjZ0xGz+Oc/1emSjXjy/rhgNdhusDmI0dM7t9r8yNgq714VV93VsJe4FGmc3HeekYQmSDp59vJul1uhzFXoCZwf6MrWF/rlbZ3b9rBpVClk0oZOmDQhYZRnnPO4QNWkaBCwzIE9zo6173/Ynx8b/vOE7CGFOrLS7+h8UXX/zToOuSW4phT3QmsDOH13e36MlbRLbcDbpcRrAnVtTlIiI3c6NulQv0dquoW0UC1QllukvVbxTMxHh1KNPtkul2zHR1Q4f1gcxmHTM76Vje5dVL5aPY53pDL0Rp0BtrtIQ94buxE6Wqk4wir93TzzfT9DpdjmEDmDT257GC/TnUfrKdQSHLJhSy9EEhiwyrvOcdwAYtE9gT3gPxyyA+NrY3d/LkL4ai0YcAWvX6V5deeunXG6XScsClya1t7G6ZBl7EdrfowEpEto26XETkFhLYUCWDulVkl+ostL5Rl0z34xS9vTIxXr1Xxt3wsOu7YjYGNE1eWyizfg/O+nFeYF9ntLABSh0boixjf3ZX2RCgADX9DItsr04YnMGeg9qDDV3GsL9nfOyFTyV04VNQFLJsQiFLHxSyyDDLe94+4N3YE03n2VlXIt2Q47ru2H33vTc2MvJfOI4TNr5fWpuf/7Xl8+e/EnRtctvi2O+7OLAIfA97RegVdbeIyHa6jS6X7sJaEdm91nerRLEneBZRt4rIK55+vhni5uPLotiAststk+D6Tpn1e2XAXuTX5tVBjLPhMR16IUp3lFc3RFnGXgW/cZxX/Vceiwz3yS6RHa5zDD6CPbm/Fxu65LC/O1r0Qpd6QCUOG4Usm1DI0geFLDLs8p63B9vRchAoMCBBC0Bq//7j2aNHf8kNh48DNNfW/mzxxRf/Q6ta1ZUPg8PBntwcxx48re9u0ckMEdl2G7pcjmN/P6nLRWT3UbeKyBbqnEC91V6Z9aFMEhvEgA1OVrDjvDbbh6KTriK7zLoLn7qhy1FsCBPHhi6lzlsjqBp3OYUsm1DI0geFLCKQ97wxbNByFBu0DMzJIzccDo/ff/9HI+n0+x3Hcfx2++rq7Oy/LU9NfSfo2qRvCWzbcLe75UU6V5Cqu0VEgqAuF5FdpXvF7AjqVhHZcTqjhCKA+ZXHIs2g6xGRYHVGGnZDlwPYY/Es9jm8QS90aQVV4y6jkGUTCln6oJBFxMp73ijwLuxVuwMVtABkjhx5IH3w4D9xQ6F9xhjTrFQ+tfC3f/tbfqulJ9zB0z2pOYYdBTCFHSd2abJQUJeSiARGXS4iA6fbrdJdsrsCzGA7Z9WtIiIiMiCefr4ZxR57T2AnsRzEhi5h7HmDEvYiKB2L3xmFLJtQyNIHhSwiPXnPG8EGLR42aBmogCKcSCTG7r33v44kkz8A4Lfbs7XFxd9eLhS+YHxfTxKDqXtCMwYsAN8FLmK7W4b7CUxEAqUuF5EdSd0qIiIiQ+Dp55txeqHLEexFUBnssfgaNnRZZYBG4gdMIcsmFLL0QSGLyPXynpfBBi2vwwYtA9eqnTt58s3JvXv/seO6OQC/1bpctWHLcwz7L73BtbG75TJ2nNjlyUKhFmRhIiKgLheRAKlbRUREZMg9/XwziQ0KJrCj8CewoYuD3fNU6rzXOaHNKWTZhEKWPihkEXm1vOelsEHLvdgr/wZusVg4Hk/kPG8ymsm8z3HdFIDfal2sFovPLJ8//5Wg65PXJIk9kRkFrtHrbrmm7hYR2QnU5SKypdStIiIiIjf19PPNDL3Q5Rj22DzduXuVXugilkKWTShk6YNCFpHN5T0vCbwTeBD7orUeaEF3KJxIJHOe995oOv1ex3WTAH6z+fJasfjMyoULfxV0ffKauNgrxcewJyu73S1T6m4RkZ1kXZfLXuAE6nIR6Ze6VUREROSOPP1808Hub5kA9mC7znPY43GDvQiqhL1wY1gpZNnEQIcsjuP8Y+CXgf3AXwM/b4z56k3+fA74F8D7sSfaLgG/aIz5zG1+PYUsIjeQ97w48A7gYezP1sCeuI6kUuncyZM/EUmnf9xxnDhAu9l8cW1+/pnSpUvfDLg8ee1S2IOlCFDEdrdcAIrqbhGRnURdLiK3Rd0qIiIisiU6x+M5bLCwD7vTJYe9qKNFL3QZyIuN75BClk0MbMjiOM5PAr8J/CzwFeAXgQ8C9xpj5jf581HgHPbqpX+JvZrpGLBsjPnr2/yaCllEbiLveTHg7cCj2KBloJP9aCaTHTlx4gORVOrHOr9DaDca31mbn3+mdPnyt4OuT16zEPYK8Ry29fcy8D1sd8swHSCJyIBQl4vIK9StIiIiItvu6eebIWCUXuhyFHuhRwx7TF7qvA3czuI+KGTZxCCHLF8BvmaM+bnO5y4wBfyaMebpTf78z2K7Xu4zxtzWN7rjODHsD0lXBnvgrpBF5AbynhcF3ga8AfszOfBXDkaz2dzIiRMfjCSTP+w4TgSg3Wh8q3Llym+Vp6e/G3R9cleksSctQ9irXr+LDQoX1N0iIjuRulxkyISwozvUrSIiIiI7xtPPNyPYY/IJ4GDnLYs9XmnQC11aQdW4BRSybGIgQ5bOFeVrwFPGmE+vu/03gJwx5r2b/J3PYA/E14D3Yhcgfwz4V8aYTa/4cxznnwP/4yZ3KWQRuYm850WAJ4E3ArPYRWEDL5bLjY8cO/bBcDL5g47jhAHa9fpfrc7NfWx1dvaloOuTuyKEPWDIYb9vLwIvYbtbGsGVJSJyc+pykV1I3SoiIiIyUJ5+vhnFHodPYC+E2o8NXcLYsfrd0GWQj2EUsmxiUEOWg9gD7CeNMV9ad/u/Bt5hjHnzJn/nu9hlRc8A/xtwqvP+/2GM+Z9u8HXUySJyh/KeFwbeCrwJmMNeVbsrxMfG9mSPHv3JcCLx7k4XHa16/aurs7PPVObmLgRdn9w13e4WF3sy5wXg0mShsBBoVSIit3CTLhcXGyCry0V2InWriIiIyK7y9PPNODaUmMDuc9mHPb/sYseWl7HH54MUVihk2cQwhSzfA+LAiW7niuM4vwT8sjHmwG1+Xe1kEelD3vNCwJuBt2BfHO+qn5vExMT+zJEjPxmOx8+8ErbUas+tzsx8rHL16uWg65O7Jow9iBjBHgBdAF7Gdrfs5jmrIrJLqMtFdjB1q4iIiMjQePr5Zopep8tRYA/2OMjBhi6lzvudcRJ+cwpZNjGoIcudjAv7PNA0xrx73W0/AnwGiBljbjkGRiGLSP/ynucCT2DHhxWB5UAL2gLJPXsOZQ4f/qlQPP59juM4xhjTrtW+UJ6Z+e21+fmZoOuTuyqDPQhyuL67ZTHQqkREbpO6XCRg6lYRERER6Xj6+WYGG1rswYYu49jQxccem5fYecfmClk2MZAhC7yy+P6rxpif73zuApeBX7/B4vt/CXwEOGmM8Tu3/TfA/8UYc/A2v6ZCFpE70AlaHgdOA0vYF9O7TmrfvqPpQ4c+Eo7HnwQwxvitWu3z5amp36kWi3NB1yd3VRh7EDSCfV7odrdMq7tFRAZJp8tlD3Z0gbpcZCuoW0VERETkFp5+vulgzzF0Q5dj2GOoFDZ0KWNDl2pAJXYpZNnEIIcsPwn8BvAPgK8Cvwh8CLjPGHPVcZzfBGaMMf+08+ePAN/p/J1fA+4B/j/YnSz/4ja/pkIWkTuU9zwHeAx4G/ZJYdfutUgdOHAiffDgR8Kx2JuhE7ZUq39eunz5d2qLi9eCrk/uuiz2AAjgCvBdbHfLUnAliYj0T10ucpeoW0VERETkNeocm+ewocY+bKdLDrsOo4U9t1YCbjmd6S5TyLKJgQ1ZABzH+Tngl4H9wDeBXzDGfKVz3+eAi8aYn1n3598K/CrwKPbqqf8E/Kvujpbb+HoKWUReg07Q8gjwduyMyV0dOKQPHrwnfeDAR0Kx2OMAxphWa23tT1cuXfq9+vLyrg2ZhlgEe7CRwV5hcp5ed0sryMJERO7Ehi6X49jfcepykc2oW0VERERkCz39fDOEvSBqAnsu/DC9i1qa2MCl3Pl4Kylk2cRAhyzbTSGLyGvXCVoeBN4B1LFXNO5qmcOH70vt3/+RUDT6KLwStnx25eLFZ+srK+p22J26Lb4G+z3e3d2yHGRRIiJ3qnMl3Sg2cFGXi6hbRURERCRATz/fjGBH/Y4DB7HH51nsBaB1eqHL3b7oUyHLJhSy9EEhi8jdk/e8B7BBSxsYin0l2aNHH0ru3fuRUDT6EIAxptGsVP5o5cKFTzTKZf1O2Z0i2KvAs8AyUMB2t8yqu0VEBtkmXS7j2HnRLezvO3W57D4bu1WWgVnUrSIiIiISuKefb8awx+QT2Iui9mHPRYSxF8R0Q5fXerymkGUTCln6oJBF5O7Ke969wJnOpzNB1rKdsseOvT65d+9PhyKRewGMMbXm6mp++cKFTzdXV8tB1ydbJoc9GPGxweJ3gYuThYKeT0RkoK3rcunucumOLlCXy2C7UbfKeWy3yjV1q4iIiIjsTJ2LoiY6b0ewx+oZ7DF6BRu6rGIvnumHQpZNKGTpg0IWkbsv73mngHdhk/WpgMvZViMnTjyenJj4iBuJ3ANgjKk2yuXfXz5//vdba2uVoOuTLRPFXv2dxl4F/DL2hNXMZKGgq75FZOA9/Xwzjn0Rpy6XwdPtVslgLwpYRt0qIiIiIgPv6eebKXqhy7HO+3Tn7lVs6LLGrUMXhSybUMjSB4UsIlsj73kngO8H4sClgMvZdrmTJ9+cmJj4qBsOHwcwvl9plMufWi4U8q1arRpwebK1cvS6W2aw3S2XJgsFdTSJyK6gLpcdT90qIiIiIkPm6eebDvaimgnsRaBHgTHshVGG60OXjRSybEIhSx8UsohsnbznHcN2tKSBi8FWEwDHcXInT741MT7+ETccPgpgfL9cL5U+sVwo/FG7Xq8HXaJsqY3dLd/DnuCaU3eLiOwm67pc9gInUJdLENStIiIiIiKv6IQuOXqhy7HO50nssXkZG7rUUMiyKYUsfVDIIrK18p53GNvRksOeYB46juu6Oc97W3xs7KfcUOgQgPH95Xqp9Imll1/+Y7/RaARdo2yp7oHNOPagZRZ4AdvdshpgXSIid90Nuly6yzlXsSf/1UXx2m3sVlnDdqtcwHarzP/KYxF1zoqIiIgIcN1x+gR2BPBR7LFkHIhgz1UoZFlHIUsfFLKIbL285x3EBi1j2Bf/Q/mLx3FdN3fq1Dvjo6MfdkOh/QDG9xfry8u/t/Tyy//Zb7VaQdcoWy6GvYIkBSxxfXeLDmREZNdRl8tdtVm3ygy9bpVFvSgWERERkdvx9PPNMPY83QSwHzv6989/5bHIUJ6z24xClj4oZBHZHnnP248NWvYCBYY0aAFwQqHQ6KlT74rlch92Q6E9AH67XawvL//u0ssv/5lpt3WyafdzsFeQjANN7AmyF7HdLZUgCxMR2Sq30eWyAuh3YE8Ie3XhCPbqQnWriIiIiIhsE4UsfVDIIrJ98p63B3g3NiE/j70Kc2i54XA4d+rUD8ZzuQ85rjsG4LfbV2tLS7+z/PLLZ43vD/V/nyHSvco7ASxgu1suAFfU3SIiu5m6XDa1vluljf1voG4VEREREZFtppClDwpZRLZX3vPGsUHLYeBlhjxoAXAjkcjoqVM/HBsZ+aDjujkAv92erS0u/vZyofAFhS1Do9vdMgE06HW3TE0WCuUgCxMR2WobulwOAUcYji4XdauIiIiIiOxACln6oJBFZPvlPW8UG7QcxY4OG7arVDcVisViOc/70Vg2+5TjuhkAv9Waqtqw5RzD/gt7uCSwu1vi2Oeol7En3GYnC4VmkIWJiGyH2+hyKXU+HkTqVhERERER2eEUsvRBIYtIMPKeN4Ld0XISG7QM6omSuy4cjydynveeaCbzPsd10wB+q3WxWiw+s3z+/FeCrk+2lYM9ETeO7fq6BnwXmAKKk4XCcD+Ji8hQ2AVdLupWEREREREZMApZ+qCQRSQ4ec/LAu8CTqGg5VXCiUQy53k/Hk2nf8Jx3SSA32wW1orFZ1YuXPh60PXJtotgR4llsScVp4GXsOPE1oIsTERkOw1Il0sSG6qoW0VEREREZAApZOmDQhaRYOU9Lw2cAe4DzmN3Ucg6kVQqnTt58ici6fSPO44TB2g3my+uzc8/U7p06ZsBlyfBSGHHiUWxV0N3x4nNTRYKGr8nIkNjB3W5bNatsgBcRN0qIiIiIiIDRyFLHxSyiAQv73kp4J3A/dgTxQpaNhHNZLIjJ068P5JKvcdxnChAu9H4ztr8/DOly5e/HXR9EojuycUx7FXbV4AXsd0ti0EWJiIShG3uclG3ioiIiIjILqWQpQ8KWUR2hrznJYB3AA9jg5Z6sBXtXNFsNjdy4sRTkWTyRxzHiQC0G41vVa5ceaY8Pf1C0PVJYKLY7pY09iTiRWx32PRkoVALsC4RkUBsQZeLulVERERERIaEQpY+KGQR2TnynhcH3g48AlwGdKLiJmK53NjIsWMfCieTP+g4ThigXa9/Y/XKlWdWZ2ZeCro+CVQWu78lBBSx3S2XgauThYKuqhaRoXSHXS7qVhERERERGUIKWfqgkEVkZ8l7Xgx4G/AYMIW9SlRuIj42tid79OhPhhOJdzuO4wK06vWvrc7OPlOZmzsfdH0SqBB2lNgotjtsBvgedpyYnvNEZGjdosulgu0OVLeKiIiIiMiQUsjSB4UsIjtP3vMiwGngcexJ4e1YWDvwEhMT+zNHjvxkOB4/80rYUqs9tzoz87HK1auXg65PApfAdrcksM9757Gj+aYnC4VmkIWJiARtQ5fLcWxXi7pVRERERESGlEKWPihkEdmZ8p4XBp4EngDmgHKwFQ2O5J49hzKHD384FI+/3XEcxxhj2vX6F8vT0x9bm5+fCbo+CZyDHX0z3vl4HvgutnPs2mShMNwHBiIiIiIiIiIy9BSy9EEhi8jO1Qla3tx5u4q9qlRuU3LfvqOZQ4d+KhyPnwYwxvitWu3z5amp36kWi3NB1yc7QhgbtuSwI3GmgJew48TUQSYiIiIiIiIiQ0khSx8UsojsbHnPC2G7Wd6KXeC9HGhBAyi1f//x9KFDHw3HYm+GTthSrf556fLl360tLs4HXZ/sGCnsOLEYsAS8jN1BMDtZKGxcBC0iIiIiIiIismspZOmDQhaRnS/veS7wRuyelgXsCWDpU/rgwVPpAwc+GorFHgcwxrRaa2t/Wrp8+dna0lIx6Ppkx3CxnS1jgI/tIvsutrtlIcC6RERERERERES2hUKWPihkERkMnaDlUeD7sN0si0HWM8gyhw/fm9q//6OhaPRReCVs+ezKxYvP1ldWFGDJelFsd0sGuxfpElDABi61IAsTEREREREREdkqCln6oJBFZHDkPc8BXg+8HXvCV90Xr0HmyJEHU/v2fTQUjT4EYIxpNCuVz6xcuPCJRrm8EnR9suNkgD1ACNtR9hJ2nNiVyULBD7AuEREREREREZG7SiFLHxSyiAyWTtDyEPAOoIYdZSSvQfbYsUeSe/f+dCgSuQ/AGFNrrq7+4fKFC59qrq6Wg65PdhwXO0psFGgCc8CLwOXJQkHhnIiIiIiIiIgMPIUsfVDIIjKY8p73IDZoaQJXAi5nVxg5ceLx5MTER9xI5B4AY0y1US7//vL587/fWlurBF2f7Ehx7DixJFACLgDngenJQqERZGEiIiIiIiIiIndKIUsfFLKIDK68590HvBMwwGyw1eweuZMn35SYmPioGw6fADC+X2mUy59aPn8+36pWq0HXJzvWCDZwAbiGHSd2CZifLBSG+2BDRERERERERAaKQpY+KGQRGWx5z7sHOIPdEzEdcDm7h+M4uZMn35oYH/+IGw4fBTC+X26Uy59cevnlP2zX6/WgS5QdKwyMY0OXGvbn8iXsOLHVIAsTEREREREREbkdCln6oJBFZPDlPe8k8C4gBlwOuJxdxXFdN+d5b4uPjf2UGwodAjC+v1wvlT6x9PLLf+w3GhoJJTeTxHa3xIFl4GXgIjA7WSg0gytLREREREREROTGFLL0QSGLyO6Q97zj2KAlhT2JK3eR47pu7tSpd8RHR3/KDYX2AxjfX6yvrDy79NJLf+K3Wq2ga5QdzQFGgTHAB64CLwJTwILGiYmIiIiIiIjITqKQpQ8KWUR2j7znHQG+H8hiF3DLXeaEQqHRU6feFcvlPuyGQnsATLtdrK2s/N7Syy//mVHYIrcWwXa3ZIFVbPfZy8D0ZKGwFmRhIiIiIiIiIiKgkKUvCllEdpe85x3CBi2j2KBluH/JbREnHA6Pnjr1A/GRkQ85odA4gN9uX60vLf3O0ssvnzW+7wddowyENDZwiQBLwPewnWhXJguFdoB1iYiIiIiIiMgQU8jSB4UsIrtP3vP2Y4OWvdgTtuqu2CJuJBIZPXXqh2IjIx9yXDcH4Lfbc7XFxd9eLhT+UmGL3CYXO0psFGgCV+iME5ssFJaCLExEREREREREho9Clj4oZBHZnfKetxf4PuAEsAAUg61odwtFo9HcqVM/FstmP+C4bhbAb7WmqjZsOcewP9lIP2LY7pY0UMIGpQXsOLF6gHWJiIiIiIiIyJBQyNIHhSwiu1fe82LAg8AbsPsfpoBaoEXtcuF4PJHzvPdEM5n3Oa6bBvBbrYvVhYWPLRcKXw66Phk4WWzg4mKD0hexO1zmJwsFdUmJiIiIiIiIyJZQyNIHhSwiu1/e8/YAjwP3YUOWOUAnaLdQOJFI5jzvx6Pp9E84rpsE8Fut82vXrj2zcuHC14KuTwZOCBgHctif4Vns/pbLk4VCOcC6RERERERERGQXUsjSB4UsIsMh73kucA/wRuAgNmhZCbSoIRBJpVK5kyffF0mnJx3HSQC0m80Xq9euPbNy8eI3Ay5PBlMC2APEsT/DL2NHis1MFgrNAOsSERERERERkV1CIUsfFLKIDJe856WAR4HXAxHsCDGdmN1ikXQ6kzt58gORVOo9juNEAdrN5t+uXb36TOny5b8Juj4ZSA4wgh0nZoB54LvYn+niZKEw3Ac4IiIiIiIiInLHFLL0QSGLyHDKe94hbFfLKezvgKvBVjQcotlsbuT48Q9EUqkfdRwnAtBuNL5VuXLlmfL09AtB1ycDK4IdJzYCrALT2A6XqclCoRJkYSIiIiIiIiIyeBSy9EEhi8jwynteBLgfu69lHHtiVidkt0EslxsbOXbsQ+Fk8gcdxwkDtOv1b6xeufLM6szMS0HXJwMthR0nFgUW6Y0Tm50sFNoB1iUiIiIiIiIiA0IhSx8UsohI3vNGgTcADwEtYAbQydhtEB8dncgeO/aT4UTi3Y7jhABa9frXVmdnn6nMzZ0Puj4ZaC4wCoxhf66vAC9iu1sWgyxMRERERERERHY2hSx9UMgiIgB5z3OAE8ATwBHgGvYqeNkGifHxfZmjRz8cjsfPOI7jArRqtS+tzs5+rHLlyqWg65OBF8V2t6SBEnAJKADTk4VCLcjCRERERERERGTnUcjSB4UsIrJe3vMSwMPAo9ixQ1NAPciahkliz56D2cOHfyoUj7/dcRzHGGPa9foXy9PTH1ubn58Juj7ZFTLYwCUEFIHvYUOXq5OFgh9kYSIiIiIiIiKyMyhk6YNCFhHZTN7z9mG7Wl6HXaR9BRjuX5jbKLlv39HMoUMfDsfjbwMwxvjtWu3zpamp36kWi3NB1ye7Qgg7SmwUG6TOYceJXZ4sFHQ8ICIiIiIiIjLEFLL0QSGLiNxI3vNC2JDlCWAvMAuUAy1qyKT27z+ePnToo+FY7M1gw5ZWtfrnpcuXf7e2uDgfdH2yaySAic77FeACcB6YmSwUGkEWJiIiIiIiIiLbTyFLHxSyiMit5D0vix0f9jD26vcp7CJt2Sbpgwe99IEDHw3FYm8EMMa0W9Xqn5YuXfq92tJSMej6ZNdwgBFgvPPxPJ3uFuDaZKEw3AdNIiIiIiIiIkNCIUsfFLKIyO3Ie54DHMF2tZwAFrD7HGQbZQ4fvje1f/9HQ9HoowDGmFZrbe2zKxcvPltfWVkKuDzZXcLYsCUHrGHD1Zex48QqAdYlIiIiIiIiIltMIUsfFLKISD/ynhcFHgDeiL3ifQqoBlrUEMocOfJgat++j4ai0YcAjDGNZqXymZULFz7RKJdXgq5Pdp0UdpxYDFjChi0XgdnJQkFdbSIiIiIiIiK7jEKWPihkEZE7kfe8ceBxbOBSx+5r8QMtaghljx17JLl370+HIpH7AIwx9ebq6h8uX7jwyebqqvbnyN3mAKPAGPbn/SrwXWBqslBYCLIwEREREREREbl7FLL0QSGLiNypvOe5gIcdIXYIuAIsB1nTsBo5fvwNyT17PupGIvcAGGOqjXL595fPn//91tqaRjvJVohix4llgVVsZ0sBmJ4sFNTdJiIiIiIiIjLAFLL0QSGLiLxWec9LAa8HHgHi2BFijUCLGlK5kyfflJiY+KgbDp8AML5faayufnq5UPiDVrWqE9+yVTLYcWJh7L6ml4BLwNxkoaAONxEREREREZEBo5ClDwpZRORuyXveQeyulnuwv1euBlvRkHIcJ3fy5FsT4+MfccPhowDG98uNcvmTSy+//Ifter0edImya7nYUWKjQBOYA17EjhNbDrAuEREREREREemDQpY+KGQRkbsp73kR4F7sCLFxYBrQuKogOI4z6nlvi4+NfcQNhw8BGN9fqZdKH196+eU/9hsNdRvJVopju1uSQInrx4npe09ERERERERkB1PI0geFLCKyFfKelwMeAx7q3DQFtAMraIg5ruvmTp16R3x09KfcUGg/gPH9xfrKyrNLL730J36r1Qq6Rtn1RrCBiwNcA76HHSc2P1koDPeBmIiIiIiIiMgOpJClDwpZRGSr5D3PAY5jR4gdw55cXQyypmHmhEKh0VOn3hXL5X7SDYX2Aph2u1hbWfm9pZdf/jOjsEW2Xhjb4ZYDqthOt5ew48TKAdYlIiIiIiIiIusoZOmDQhYR2Wp5z4tjO1reAKSBy4D2ggTECYfDo6dO/UB8ZORDTig0DuC321fry8u/u/TSS39hfF+LymU7JIA92LFiy8DL2JFis5OFQjO4skREREREREREIUsfFLKIyHbJe95ebFfLvcAadin2cP8SDpAbiURGT536odjIyIcc180B+O32XG1x8beXC4W/VNgi28TBdraMAz4wD7yIDWMXNE5MREREREREZPspZOmDQhYR2U55zwsB92DDlgPALHYptgQkFI1Gc6dO/Wgsm33Kcd0sgN9qTdcWFz+2VCicY9ifKGU7RbC7W7LAKtePE1sLsjARERERERGRYaKQpQ8KWUQkCHnPywCPAo9g9zRcBrQTJECheDw+6nnviWYy73dcNw3gt1oXqwsLH1suFL4cdH0ydNLYwCUCLAHfAy4Bc5OFQjvIwkRERERERER2O4UsfVDIIiJBynveEWxXy0nsXob5QAsSwolEMud5Px5Np3/Ccd0kgN9qnV+7du2ZlQsXvhZ0fTJ0XGAMGAWawBXsOLGpyUJhKcjCRERERERERHYrhSx9UMgiIkHLe14UuB8btuSAKaAaZE0CkVQqlTt58n2RdHrScZwEQLvZfLF67dozKxcvfjPg8mQ4xbDdLWnsmMGLQAGYniwU6gHWJSIiIiIiIrKrKGTpg0IWEdkp8p43BjwOPIAdHTaNXYQtAYqk05nciRPvj6TT73EcJwbQbjb/du3q1WdKly//TdD1ydDKYgMXFyjSGyc2P1ko6PeGiIiIiIiIyGugkKUPCllEZCfJe56LHR32RuAIdjTQcpA1iRXNZnMjx49/IJJK/ajjOBGAdqPxrcrVq8+Up6ZeCLo+GVohYBzbBVcDZrGBy9RkoaDjGhEREREREZE7oJClDwpZRGQnynteEngYeAxIAJeBRqBFCQCxkZGxkePHPxhOJn/IcZwwQLtef371ypVnVmdmvhd0fTLUEsCezvtl4HznbWayUGgGWJeIiIiIiIjIQFHI0geFLCKyk+U97wC2q+UeYBXb2TLcv7h3iPjo6ET22LEPhROJH3AcJwTQqte/VpmdfWZ1bu580PXJUHOAEew4MQPMAy9iw9riZKGg3yEiIiIiIiIiN6GQpQ8KWURkp8t7Xhi4F7uvZS8wgw1cZAdIjI/vyxw9+uFwPH7GcRwXoFWrfWl1dvZjlStXLgVdnwy9MDZsGQEq2F1PL2HHiVWCLExERERERERkp1LI0geFLCIyKPKeN4IdH/Zw56ZpoBVcRbJeYs+eg9nDhz8cisff4TiOA9Cq1b5Ynp7+2Nr8/HTQ9YkAKew4sSiwCLwMXATmJgsF/S4RERERERER6VDI0geFLCIySPKe5wDHsCPEjgMLQDHImuR6yb17j2QOH/6pcDz+NgBjjN+u1T5fmpr6nWqxOBd0fSKAC+SAcWxQewU7TmxqslBYDLAuERERERERkR1BIUsfFLKIyCDKe14MeBA7QiyL3bVQC7QouU5q//7j6YMHPxKOx98CNmxpVat/UZqa+t3awsLVoOsT6Yhix4llgBL2d0kBG7jod4qIiIiIiIgMJYUsfVDIIiKDLO95e7BBy33YkGUO8AMtSq6TPnjQSx048JFwLPYEgDGm3apW/7R06dLv1ZaW1IUkO0kGG7iEsF1y38OGLlcmCwX9XhEREREREZGhoZClDwpZRGTQ5T3PBe7BjhA7CMxir0iXHSRz6NC9qQMHPhqKRh8FMMa0Wmtrn125ePHZ+srKUsDliawXAsaAUaCODW+748RWgixMREREREREZDsoZOmDQhYR2S3ynpcGXt95iwBTQDPQouRVMkeOPJDat++nQ9HoQwDGmEazUvnjlQsXPt4ol3UCW3aaOLAHSALLwIXO2/RkodAIsC4RERERERGRLaOQpQ8KWURkt8l73iHgCcDD/n7T/o8dKHvs2CPJvXs/GopE7gcwxtSbq6t/uHzhwiebq6vloOsT2cABRoDxzsfzdLpbgPnJQmG4DyilL3nPc7DfR27n/fq327ntTv9eP7etAHOThUJ1q/47iIiIiIjIzqWQpQ8KWURkN8p7XgS4H7uvZRx7InQt0KJkUyPHjz+W2LPnp0ORyD0AxphqY3X1D1bOn/90s1KpBF2fyCbC2N8rI0AV+/vlZew4sdUgCxsE6wKGuxEsbGcwsfEttO7Prv98423OuvfuhsfnBv8eOn+OTW670d/r3tb9e3fCrHs8n1731hQ2cNHzqIiIiIjIkFDI0geFLCKym+U9bxR4A/Ag0AZmOu9lhxk5efKJ5MTER91w+CSA8f21ZqXymZVLl/6gUSotB1yeyI0ksePEYsASNmy5CMxOFgqtzf7ChpBhqzsSbvfv3c6f3RgkbAwcNoYRN7qNdY8Jrw4TNgsO7iSEMOvuZ91t6z9n3Z+51YsCgw0euh93//zG28yG+290+40ea+Pfu5OvcTe4QA67m8jFBi4XsYHL7GShoBBcRERERGQXU8jSB4UsIrLbdU5onsSOEDsMXAMWAy1KNuc4Tu7kybckxsc/4obDx8DubGmtrf1paWrqU7XFxfmgSxS5AQd7MnoMe0L8GlCn18WwPmiAO+9SuN3bNwsTbue2zYKJ7u23Cgjudghxo2DiZvffzZBBerqBSw77/bwCXAIuYwMXdXCJiIiIiOwyCln6oJBFRIZF3vMSwMPAo0AKe3JIi6t3IsdxcidOvCk+Pv7BUCTyOgBjjN+q1T6/OjPz8bX5+amgSxS5iSi9q//vJCB4LSGEQgbZai52VN4oNnApYZ9PL2FHiun1hIiIiIjILqCQpQ8KWURk2OQ9bz/wRuB1wCpwBZ2U3LGyx449ktyz56lQNPpo97ZWrfblytWrz67OzLwUYGkiIsPOwQYuY/QClyls4DKrwEVEREREZHApZOmDQhYRGUZ5zwtjQ5Y3AnuBWaAcaFFyU+mDB+9J7d//VDgef2v3tnaj8ddr1649W7p06VtB1iYiIjhAFhu4RLCByzR2j8vcZKGwHFhlIiIiIiLSN4UsfVDIIiLDLO95Wez4sEewJ4imgU2XVcvOkNy790j60KEPhOPxdzqO4wK0m83v1RYWnl2+cOGrDPsTu4hI8Bwggw1cotiLGGaB88AcsDxZKOh3tYiIiIjIDqaQpQ8KWURk2OU9zwGOAE8AJ4AFoBhoUXJL8bGxPdkjR94XTiZ/0HGcKIDfal2uLS19Yvn8+b807XY76BpFRAToBS4x7JjO9YHLkgIXEREREZGdRyFLHxSyiIhYec+LAQ8Aj2NnzE8B1UCLkluKZrO5kWPHJiOp1I85rpsE8Nvtq/WVlU8tnz//Z36j0Qi6RhEReUUGGAXiQAUbtJzHBi+LClxERERERHYGhSx9UMgiInK9vOdNAG/ABi517IkfP9Ci5JbCiUQyd/Lkj0Yzmfc6rjsCYHx/uVEu//7y+fOfaVWrCsxERHaWNLbDpRu4XKHX4VJU4CIiIiIiEhyFLH1QyCIi8mp5z3MBDztC7BD2xM9ykDXJ7XGj0ejoyZPvjo6MfMANhfYAGN+vNCuVP1q5eDHfKJdXgq5RREReJYUNXBLAGnAVKNALXHSxg4iIiIjINlLI0geFLCIiN5b3vBTweuAR7Cz5KaAZaFFyW5xQKJTzvLfHc7mn3HD4CIAxptFaW/vPpcuXP1lbWtLeHRGRnSmJHSmWAmrYwOVlbOByTYGLiIiIiMjWU8jSB4UsIiK3lve8g9iullPY35lXg61IbpvjOLmTJ98cHxv7YCgSuQfAGNNu1WqfW52Z+fja/PxM0CWKiMgNJbAdLmnsnrR5bIfLLDZwaQdYm4iIiIjIrqWQpQ8KWUREbk/e8yLAvdiwZRyYxs6QlwGRPXbs9ck9ez4YikYfATDGmHa9/qXKlSvPrs7OFoKuT0REbiqB7XBJY3emXcN2uMwC8wpcRERERETuHoUsfVDIIiLSn7zn5YA3AA8BPjZs0YmdAZI+dOh1qf37PxiOxd7cva3daHxzbX7+90qXL387yNpEROS2xLGBSwZo0Atc5oCrk4VCK8DaREREREQGnkKWPihkERHpX97zHOA48EbgGPbkzmKQNUn/kvv2HU0fPPiBcDz+DsdxXIB2s/libWHh2eULF77GsB8kiIgMhhh2pFg3cFmg1+FydbJQ0C41EREREZE+KWTpg0IWEZE7l/e8OPAw8Bh2Qe8UdoSJDJD4+Pi+7OHD7wsnkz/gOE4EwG+1LtWWlj6+XCh8wfi+liyLiAyGKLbDZQRocn3gckWBi4iIiIjI7VHI0geFLCIir13e8/Ziu1ruBdaw40qG+wlmAEWz2dzIsWPvjaTTP+o4TgLAb7ev1ldWPrFcKPy532zq5JyIyOCIYDtcRoAWrw5cGgHWJiIiIiKyoylk6YNCFhGRuyPveSHgHuAJYD8wA5QDLUruSDiZTOVOnPixaCbz447rZgGM7y/VS6VPr5w//9lWrVYNukYREelLhF6HSxs74rOAfa6+MlkoqAtVRERERGSdLQ9ZHMd5szHmK3dY346ikEVE5O7Ke14GOz7sYSAMXMZeQSsDJhSNRnOe94PRbPb9big0AWB8v9KoVP5w5cKFP2iuripEExEZPGF6gYvBBi4XsCM/r0wWCrUAaxMRERER2RG2I2Txsa3m/z/gGWPM+TspdCdQyCIisjXynncEO0LsJLAEXAu2IrlTTjgczp08+Y54LveUGw4fAjDG1Jtra39Svnz507WlpWLQNYqIyB0JA7nOG9jn6/PANDA3WSioc1FEREREhtJ2hCwfAT4K/AAQAr6MDVx+zxiz2PcDBkghi4jI1sl7XhS4Hxu25LBXyeqEzYByXNcdOXHiLYmxsafcSOQUgDGm1apWz5ZnZj5RvXZtNugaRUTkjoWwHS65zufLXB+4rAVTloiIiIjI9tu2nSyO40wAHwY+ArwFaACfBX4L+ANjzI5fpqiQRURk6+U9bwx4HHgAaGJnwPuBFiWvycjx448mJiY+GIpGHwYwxph2vX5udW7u45W5uYHtcBUREcAGLiPY0MXFdrhcxF4sMTdZKFSCK01EREREZOsFsvjecRwPG7Z8FLv4eAX4OPCbxpgv3pUvsgUUsoiIbI+857nY0WFvBI4AV7BXycoAyxw+fG9y374PhmOxN3Vva9frf1WZn/94eWrqO0HWJiIid4WL7W7pBi7L2H1rl7CBy2pglYmIiIiIbJGgQpaDwE8B/wXwCPZqpxYwAXwD+LvGmL+9K1/sLlLIIiKyvfKel8Q+TzwKxLFXxe74zke5udT+/cfSBw48FYrHv89xHBeg3Wy+UC0Wn125cOHrQdcnIiJ3hUuvwyWMfR11GdvlMjdZKJSDK01ERERE5O7ZznFhGeApbPfKO7CjX/4Y+E0g3/n8fcD/Clwxxrz5jr/YFlHIIiISjLznHcB2tdwDlIGrwN1J/iUwiYmJ/ZnDh98fTiTe7ThOGMBvtS7WlpY+vlwofNH4vsbEiYjsDi6QxQYuEXqBy2VgdrJQ0GsrERERERlY27H4/r3YYOU92KuQv4YNVn7HGLOwyZ//PwH/T2NMtO8vtsUUsoiIBCfveWHgXmzYMgHMAho7sgvERkZGs8eOvTeSSv2I4zgJAL/dnqsvL39yuVD4c7/VagVdo4iI3DUOvQ6XCFACprEdLrOThcJKcKWJiIiIiPRvO0IWHzve5bewO1devMWffxPwD40x/2XfX2yLKWQREQle3vNGgMeAhzs3TQHt4CqSuyWSSqVGTpx4TzSd/nHHdTMAxvcX66XSp5fPn/9su1arBV2jiIjcVQ6QAcaAKLZbdQa4gB0pthRgbSIiIiIit2U7QpZ3GmM+d2fl7SwKWUREdoa85znAMeCJzvsi8KruSBlMoVgsljt58odi2ez7nFBoHMD4/mpjdTW/cvHiHzZXVzXHX0Rkd8oA4/QCl1k6gQuwNFkoaFSoiIiIiOw4gSy+H1QKWUREdpa858WBB4DHsbPeLwPqdtglnHA4POp574zlck+5odBBAGNMrVmp/Enp8uVP1ZeXF4OuUUREtky3wyWODVzmgPOd94sKXERERERkp9iOTpb/G/AeY8yjN7j/eeDTxpj/qe8H32YKWUREdqa85+3BBi33YUOWOUBL03cJx3XdkZMn35oYG/ugGw6fBDDGtFrV6l+Up6c/US0W54KuUUREtlQaG7gksPvYrgAF7PP9ggIXEREREQnSdoQs3wU+ZYz5pze4/18A7zPGPND3g28zhSwiIjtX3vNCwCngjcBB7IgR/a7eZUaOH39DYmLiqVA0+hCAMcZv1+vnVufmPl6Zm7sQdH0iIrLlUtjAJQlUsIHLeezz/sJkoaCLLERERERkW21HyLIG/IIx5j/e4P7/Gvh3xphU3w++zRSyiIjsfHnPSwOv77xFgCmgGWhRctdlDh++P7lv31PhWOyJ7m3tev3rlfn5Z8tTUy8EWZuIiGybFDCKDVyqwDzwMjZwKSpwEREREZHtsB0hyzzw740x/+wG9/8L4GeNMeN9P/g2U8giIjI48p53GHgCOIn93X012IpkK6T27z+ePnDgqVA8/jbHcVyAdrP5t9Vi8dmVCxf+Kuj6RERk2ySwHS5pbOByld5IsXkFLiIiIiKyVbYjZPk94J3AY8aYmQ33HQG+AXzeGPNU3w++zRSyiIgMlrznRYD7sSPERoFpYC3QomRLJCYmDmQOH35fOJF4t+M4YQC/1TpfW1z8+PL5888Z39fJNRGR4dENXFLYXW3XsB0u3cClHWBtIiIiIrLLbEfIci/wVcAA/wn4Tueuh4C/BzjAW4wxO360h0IWEZHBlPe8UeBx4AGgjQ1bdNJ9F4qNjIxljx17bySV+hHHceIAfrs9W19e/sRyoXDWb7VaQdcoIiLbKo690CIDNLCBy0v0Ahc9L4iIiIjIa7LlIUvnizwC/BrwfRvu+kvsvpZv3dEDbzOFLCIigyvveS5wAjtC7DB2bvtSoEXJlomk05mR48d/LJpOTzqumwEw7fZCvVz+9PL583/SrtVqQdcoIiLbLobtcOkGLkV6O1yuKnARERERkTuxLSHLui82gZ2ND3DeGFN8TQ+4zRSyiIgMvrznJYCHgcewi3IvY0+0yC4UisfjuZMnfyiWzb7Pcd0xAOP75cbqan7lwoU/bFYqq0HXKCIigYhiA5cs0AQWsIHLDDZwaQZYm4iIiIgMkG0NWQadQhYRkd0j73n7sbtaXgesAlewoy1lF3LD4XDO887Ecrmn3FDoAIAxptqsVD5bunTp0/WVFXU1iYgMryh2pFgWO1a0CBSwHS5XJgsFXYwhIiIiIje0bSGL4ziHsVcNjwDuxvuNMb95xw++TRSyiIjsLnnPC2NDljcC+7BXr5YDLUq2lOO6bu7kySfjY2MfdMPhEwDGmFarWv2z8vT0J6vF4pWgaxQRkUBF6HW4tIFFbOAygw1c6gHWJiIiIiI70HYsvo8DvwF8ABuuGOyye1h3xbAxJtT3g28zhSwiIrtT3vOy2AsBHsY+R00Dmsu+y42cOPF4YmLig6FI5AEAY4zfrtW+uDo39/HKlSsXAy5PRESCF8YGLiPYwGWJXuAyp8BFRERERGB7QpZ/A/w88N8DXwI+B/xdYA74ReAg8HeMMd/u+8G3mUIWEZHdK+95DnAU29VyAjubfaB2h8mdyRw58kBq794PhmKxx7u3ter1r61dvfpseXr6u0HWJiIiO0YYyHXewHa4nMdemDE3WSjUgilLRERERIK2HSHLZeCzxpi/7zjOOHANeLcx5i869/8F8KIx5h/2/eDbTCGLiMjul/e8GPAA8Dj2ytUpoBpoUbItUgcOnEwfOPBUKBY77TiOA9BuNL5dLRafXbl48fmg6xMRkR1jY+CyxPWBi44bRLZA56KoCHaPUhTbYVaeLBT8QAsTEZGhtx0hSw34OWPMf3QcJ4ldLvxeY0y+c/8/Bv4HY8y+vh+89/d/GdgP/DXw88aYr97gz/4M8P/dcHPdGBO/za+lkEVEZEjkPW8CG7TcD9Sxy2/1Am4IJPbsOZg5dOgD4UTijOM4YQC/2SxUFxefXblw4cvG9/V9ICIiXSF6gYsDLAMXsBdpzE0WCmtBFSay03VCk25gErvBxwkgBSQ7b1Fs0BnGHptXgKvYC3pXOm+lyUJBo39FRGTbbEfIcgn434wx/6rz+QLwfzfG/C+dz/8p8CvGmJE7eOyfBH4T+FngK9jxYx8E7jXGzG/y538G+HfAvetuNsaYq7f59RSyiIgMkbznucAp7Aixg9gXcMtB1iTbJ5bLjWePHv2JSCr1w47jxAD8dnumvrz8iaVC4XOm1dKLdxERWc/Fhi2jnY+XgYvYwGV2slCoBFWYyHboHDtvDEo2hifd0CTV+TiM7U6JdD526e3xBdut0uq8NTd8HMIGL6nO4xtsB/oaNnS5Si94WZksFBpb8g8XEZGhtx0hy+8BCWPMZOfz/wP4EeCXsE+e/yvwvDHmh+7gsb8CfM0Y83Odz13sAeyvGWOe3uTP/wzwb40xub7/IShkEREZVnnPSwGv77xFsc81zUCLkm0TSaczI8ePT0bT6UnHdVMApt0u1kulTy2fP/+f2/W6Fh+LiMhG3cAlhz0RvAJcAi5jA5fVwCoTuU15zwtx8y6TGL0Ok/WhSTc4CWO//9frhiZNXh2atDr33ykHiNPrfOlOLalhg5cF7H7gFaAELGufkoiI3A3bEbK8Ddtd8t8ZY+qO4xwB/gy4p/NHCsB7jDEv9vm4UeyT5FPGmE+vu/03gJwx5r2b/J2fAf4jMIM96P0G8H81xnznBl8jhj1o6Mpg5+wqZBERGUJ5zzsIPIHtblnBXh0nQyIcjydGTp784Vg2+17HdccAjO+XGuXyH6xcvPhHzUpFVyiLiMhmXCALjGFPOq9gw5ZL2JFiem0p2yLveWFuHphE6XWZpDq3rQ9Mup0mXYbrQ5P1gUn3850wZjVGL3hJYMOYBnbU2DI2eFmm1/WyNlko9H8CTEREhtaWhyw3+KIu8DD2yfi7xpi+x204jnMQG5Y8aYz50rrb/zXwDmPMmzf5O2/Fhjvfwi4z/j8DbwceNMZMb/Ln/znwP27y5RWyiIgMqbznRYD7sCPExrDPRTq5PkTcSCSS87zvj42MvN8NhfYDGGOqzdXVz6xcuvT7jVJpOeASRURk53Kwr0XXBy7T2LFic5OFwkpwpckg6ewzuVVoEgPSXL/PpBuYdEd0bXSjDpPux7slfIhw/a4XF/tvrGC7XK5gO19K2J/T1clCYScERiIisgNtacjSWXT/W8AnjDHP3HGVmz923yHLJo8RAV4AftsY8882uV+dLCIisqm85+WANwAPYa/Qm+a1jTeQAeO4rpvzvLfFR0efcsPh4wDGmGZrbe3PytPTn6wuLKjTSUREbsbBdriMYk9+l7HHExewgctycKXJdtuwBP5GXSbdUVjdcGD9LpNucLKe4fqgZGOA0mL3hCZ3Q5je6LNu8OJjp6iU6QUv3Y6X8mShoON/ERHZlnFhJeC/Ncb8hzsr8YaP2/e4sBs8zrNAyxjzU7fxZ7WTRUREXtF5MXwC29VyFLtgczHQoiQQIydOPJGYmPhgKBK5D8AY47drtb9cnZ39eOXq1ctB1yciIjueg72ob4xe4DKLDVxmsbsjdDJ8gNxgCfzGj9ef0E9y/WiuCK/eZ+Jz8y6TvqeEyC25XP//KYL9/1AFVoF57GuAbvBSmiwUtLtRRGTIbEfI8hngijHm791ZiTd97K8AXzXG/Hzncxc72/bXN1t8v8nfDwHfAT5jjPml2/jzCllERORV8p4Xx47BfAz7AmwK0DL0IZQ9evSh5J49T4VisTd0b2vV619Zu3Ll4+WZmb72z4mIyFDrBi4x7Inc9YHLkgKX7bduCfzthiYJrg9MukvgHXrdI1u5BF62jkMvGEth/98boIYdN3YNu7uxhN31UposFPTaQERkF9uOkOUk8CfA7wL/r812n9wpx3F+EvgN4B8AXwV+EfgQcJ8x5qrjOL8JzBhj/mnnz/8PwJeBl4Ec8MvATwCPG2P+9ja+nkIWERG5obzn7QMeB+7FdlvOoREMQyl98KCX2r//qVAs9qTjOA5Au9H41tq1ax8vXbr0zYDLExGRwZLGBi5x7AncK0ABe5yxoMDlznSWwN8sMFm/LD2F/e+/fizXxiXwcP0Yrs1GdGmnx+6WoPf9EsOGMTXs64JF7M/uMp2ul8lCoRpMmSIicrdtR8hSxh58RDs3tXj11b3GGDPS94Pbx/85bFiyH/gm8AvGmK907vsccNEY8zOdz38VeH/nzy4BfwX898aY52/zaylkERGRm+pc5XgP8AT2+WYGO/JDhlByz55D6UOHPhBOJM50Omjxm82Xq4uLzy6fP/9l7uTgSkREhlkKGKcXuFzl+sBlaE/i5z0vwo1Dk+6+1fX7TDYugQ9jT4qvtz4o2WxE19D+95bbFqPX9ZLABnMNbPCyQmccIL1xYxUFpyIig2c7Qpb/g9u4itcY81/2/eDbTCGLiIjcrrznZbDjwx7GjoaYQnOyh1Z8dHQic/ToT0SSyR/u7JXDb7Wma8vLH18uFD5v2m2NAxERkX6lsB0uCewJ2/WBS3GQA5fO3rsIN+8yidPrGkjx6sDkdpbAbwxNdHJbtkOE63fxuNjvvwr24qw5bOdLN3hZHeSfZxGRYbDlIctuopBFRET60TlBcBh4I3AS20V5LdCiJFDRTCabPX58MppKvcdx3RSA325fa5RKn1wuFP603Wg0gq5RREQGUhIYxY4Wq2IDl5exJ2uvBX2CdsMS+Bt1myToBSbdfSbdwKT71uXQ22dys+BEZFCE6f0MJLEXaRls8LKK/Zku0gteSpOFgi7SERHZIRSy9EEhi4iI3Im850WBB7D7WnLYrhbNYB5i4UQiMXLixI/EstmfcFw3B2B8f6VRLv/B8oULn2mtrVUCLlFERAZXAtvh0g1c5rEdLrPYwOU1n5jthCY36zLphiZpemOSut0l65fAQ28R/Pol8JuN5lJoIsPGpdetlcT+7PjYn+tV7MVb17DjxkrYPS/NQCoVERly2zEu7O/czp8zxvxm3w++zRSyiIjIa5H3vHFs0HI/9qTBDJrlPdTcSCSS87x3x0ZG3u+GQvsAjO+vNSuVz6xcuvQHjVJpOeASRURksCXodbjUsVfCv4QNXOa7gcu6JfA3WwS/fp9JnOu7TCL0lsBvFppsNppLV+GL9M/B/lx3w5cY9uethu16KWK7XrodLyuThcLGvcgiInKXbUfIcrOTR688oDEmdJM/tyMoZBERkdeqc+Wnhx0hdgj7Img5yJokeI7rujnP+7746OgH3XD4KIAxptFaW/vT0tTUp2qLi/NB1ygiIgMvjg1cMtjF29ewu1xS3HoJfDc02azLpPteF46IBCdBr3ss1rmtgQ1eFum95ugGL2sB1CgismttR8hybJObQ8Bx4B8BR4G/a4x5oe8H32YKWURE5G7Je14SeAR4FHvSYwr7QkiGmeM4uRMnnoiPj38wFIncC2CM8Vu12udXZ2Y+vjY/PxV0iSIisivEsIFLiBuP6BrueeEig6/bgdYd2ediX2+sYc9tzWF3Rna7XiqThYJ+7kVE7kDgO1kcx/kj4KIx5h/f9Qe/yxSyiIjI3Zb3vAPYrpZ7gDL2KjO9uBGyR48+nNy794OhaPTR7m2tWu3LlatXn12dmXkpwNJEREREZDBFsKFL983FdqmtYV+LzGE7X7rBS3myUFCXmojILeyEkOUfAv+zMWbirj/4XaaQRUREtkJnDvq92LBlD3ZXy2qgRcmOkT548FRq//6nwvH4k93b2o3GX69du/Zs6dKlbwVZm4iIiIgMvBC9HS/JzucGO2qsAsx33kr0xo1pp5KIyDo7IWT5X4B/YIzJ3PUHv8sUsoiIyFbKe94I8BjwcOemKbQUVjqSe/ceTh869IFwPP5Ox3FCAO1m83u1hYVnly9c+CpbcaAmIiIiIsPIxY4Y6wYvUezepSq266UbvHQ7XlYmC4VmMKWKiARvO3ayvP0Gd+WAtwO/AHzaGPOhvh98mylkERGRrZb3PAc4BjzReV8EFgItSnaU+NjYnuyRI+8LJ5M/6DhOFMBvtS7XlpY+sXz+/F+adlvBnIiIiIjcbQ52l2Q3eIl1bqthO14WgCtcH7zUgilVRGR7bUfI4rP5bHkHe3Xus8DPG2N2/AkkhSwiIrJd8p4XBx4AHgcy2K4WvUiRV0QzmZGR48d/PJJK/ZjjukkAv92eb6ysfHLp/Pk/8xuNRtA1ioiIiMiuF6c3biyOPd9XxwYvS9jgZRl7Pq00WShUgilTRGTrbEfI8o5NbjbYX7SXBimsUMgiIiLbLe95e7BBy33YkGUO26ovAkA4kUjmTp78kWgm817HdXMAxveXG+Xy7y+fP//HrWp1LeASRURERGS4ROkFLwns+LEmdtTYMnAVWKTX9bI6WSho9K2IDKzAd7IMEoUsIiIShLznhYBTwBuBA9igRc9Dch03Go2Onjz57ujIyPvdUGgvgPH9SrNS+aOVixfzjXJ5JegaRQZNKBaLxbLZiXAyOR6KxSZCkciEGw6PO+HwhBsKjQOhVq32V9WFhXOrMzMvBV2viIjIDhamN2osCYSAFnbPSxn7GmcRG8KUsF0vurhMRAbCdnSynAAeMsbkb3D/JPA3xpiLfT/4NlPIIiIiQcp7Xhp4FHgEiGBHiGnBpFzHCYVCOc97ezyXe8oNh48AGGMarbW1/1y6fPmTtaWlYtA1iuwE4UQiGc1mJyKJxHgoFptwI5FxtxOeOKHQhOO6E47rpm738fx2+1qrWn2utrh4rjwz8yLDfoWaiIjIrYXohS4pbBDjYzteKtiOl2v0Ol5Kk4VCK5hSRURubDtClk8AWWPMD9zg/s8Cy8aYD/f94NtMIYuIiOwEec87DDwBnMRe6TUfaEGyMzmOkztx4k3x8fEPhSKRewCMMe1Wrfa51ZmZj6/Nz88EXaLIVomk05loOj0eTiQmXhWguO6EEwqNO46TuJ3HMsZUTbtdNL6/4LdaRb/VKvrN5kK70Sg6oVAils2+NRSLPeE4TvyVv+P7i61q9bnq4uK51ZmZF4zv60pcERGR2+NiR4x1g5dI5/YqNny5hg1fusHLymShoF2EIhKo7QhZZoF/a4z51ze4/5eBXzTGHOr7wbeZQhYREdkp8p4XAR7A7msZBWawV3uJvEr22LFHknv2fCgUjT4CYIwx7Xr9S5UrV55dnZ0tBF2fyG1zHCeayYxE0+nxcDw+EYpGx93uCK9QaKLTgTLuOE70dh7O+P6q8f2iabcX/Ha76LdaC36zWWzX68Xm2tpCo1wutqrV6q0ex41Go9nDhx+LjYycDsXjb14f4BjfX25Vq8/VlpbOlaenv6PARUREpG8OEKc3biyO3fdcx74GWgCu0Ol2AZYnC4VaMKWKyDDajpClCvySMeZ/v8H9/xD4VWNMfLP7dxKFLCIistPkPW8MeAy4H9tuPw3oSi7ZVPrQoXtS+/Z9MByPv6V7W7vR+Oba/PzvlS5f/naQtYk4rutGM5lcZGOAYsOT8XUBSvh2Hs/4/orx/QW/3S4a24Gy0LYBykJzba3YKJUW2vV6/W7/O9xwOJw5cuSxWC73ZDgWe8v6kWPG91datdqXaktLz5Wnp//GtNvtu/31RUREhkiMXvCSwIYxDWzwsozd87JMr+tlbbJQ0DhPEbnrtiNkeRH4mjHmp29w/8eANxljTvX94NtMIYuIiOxEec9zgCPYsMXDttHPYecZi7xKct++o+mDBz8Qjsff4TiOC9BuNl+sLSw8u3zhwte0S0LuNicUCsWy2dFIKjUR6gYo4XCvA8XuPxnrfj/ejDHGYMyS324vmHa7aNrthXazWfSbzWKrVltora0V66XSot9sBr6zygmHw9nDhx+J5XKnw/H4WxzXzXTvM75fbtVqX66vrDxXmpr6a9Nqaca8iIjIaxelN2osgR0/1sIGLyVsx8tC5+MVoKzgRUReq+0IWf458M+AfwL8ujHG79weAn4O+DfAvzDG/A99P/g2U8giIiI7Wd7zwsAp7AixA9gXD1pyLjcUHxvbmz1y5P3hZPIHHMeJAPit1qXa0tLHlwuFL2iskdwONxwOx0ZGxsPJ5EQ4Hh93I5GJUCTySveJGwqN4zijjuM4t3osY4yP7y/6vr9g2u1rfqu14LdaxXajsdCu1YrNSqVYL5WWBrEDxAmFQpnDhx+Kj46eDsfjb3Vcd6R7n/H9Sqte/0p9ZeVceWrqmzshIBIREdlFwvSClyQ2ePGxF6eV6QUv3Y6X8mShMHDHGiISnO0IWWLAHwHvwi6nerFz173AHuBzwI8YY+56q/7dppBFREQGQd7zktjxYY8BOey+ltUga5KdLZrN5kaOHfvxSDr9Y91dEn67fbW+svKJ5ULhz3XCd3iFYrFYNJsdjySTE6FYbDzU3X9il8jb8V3rwoKbMca0jO8vGN9fMK1W0W+37f6TRmOh1QlQGqXS8jCEe47rupnDhx+Ij46eDicSTzquO9q9zxhTbddqX62XSudKU1Pf8BsNjYAUERG5+1x6oUsKG8T4QBX72mkeex6zG7ysTBYK6joVkU1tecjS+SIu8HeB92PHmAAUgE8Av9ntbtnpFLKIiMgg6exreQR4EPuiQfta5KbCyWQqd+LEj0YzmR/vnjg3vr9UL5U+vXL+/GdbtdotF4DL4AgnEoloJjMRSSbHQ7HYRHeB/Cs7UOwIr/TtPJYxpmFs90nRrF8g3wlQGqurC41yeUWj6DbhOE7m8OH74mNjpyPx+GknFBrv3mWMqbXr9a/XS6Vz5ampr2/FDhkRERF5hYsdMdYNXqKAwQYva9jQ5Sp21NgyUJosFPTcLCLbE7LsFgpZRERk0HT2tRzCdrWcAmrALNrXIjcRikajOc/7wWg2+343FJoAO86oUan84cqFC3/QXF0tB12j3FwklUpHM5mJcCIxHopGJ9xIpLsDxXafhEIT3a6lWzHG1Ey7XTS+b7tPWq2i32wutOv1YqtaLTZWVxf0PXGXOI6TOXjwdfHx8SfDicRpNxTa273LGNNo1+tfb5TLz5Wnpr6m0FNERGTbrA9eYoCDfV21Bixi92Gu73jRc7TIkNmOcWFjwGFjzLducP/DwLQxZqnvB99mCllERGRQ5T0vhA1ZHsOGLotoX4vcghMOh3MnT74jnst9wA2HDwMYY+rNtbU/KV++/Ona0pK+h7ab4zjRdDobTafHw4nEhBuNToQike74rt4SeceJ3s7DGd+vGN+33ScbApRmtbrQKJWKrWp1bav/WbK59MGDpxLj46fDyeRpNxTa373dGNNsNxrfaJRKz5VnZr7aWlurBFmniIjIEIrRGzeWwAYvDaCC7XSZxXa7dMOXymShMNxXr4vsYtsRsvwGcK8x5i03uP854AVjzH/V94NvM4UsIiIy6PKeF6e3r2UMe/CvK9Dl5hzHyZ08+ZbE2NgH3UjkFNj9Gq1q9Wx5ZuYT1WvXZoMucTdwXNeNZjK5SDo9Ho7HJ0LR6LgbiUy8Mr6ruwPFccK383jG90vd7hPTahX9Vmuh3WwW2/V6sbW2tlAvlxfatVptq/9dcnekDhw4kZyY6AYuh7q3G2NafqPxzUa5fK48M/OVZqWiHVwiIiLBiNALXpLY8WMtesHLFezFbt3gpazgRWR32I6QZQr4340x//IG9/9T4GeNMcf6fvBtppBFRER2i7zn5bD7Wh7CzhqeBjRPWG4pe+zYo8k9e54KRaOPABhjTLtef64yN/fs6tzc+aDr26kc13VjIyNjkVRqPGQDFLv/JByeeKX7xHXHOrsMb8oYYzBmudt90t2B0m40iu16faG5tlasr6ws+M1mczv+bbL9Uvv2HU3s2XM6kkyedsPho93bjTFtv9H4VmN19dzq7OyXG+WyXrOIiIgEK0xv1Fii87mPDV4WgSlgofPx8mShoLHOIgNoO0KWGvALxpj/9w3u//vAvzPG3NZM6CApZBERkd0m73kHgTdgR4k1gRmgHWhRMhAyhw7dm9y//6lwLPbm7m3tev0blfn5Z8tTU98Jsrbt5obD4ejIyHgkmRwPx+N2/4ntQBl3QqEJNxSawHFytxmg+Pj+ot9ZIu93OlD8RqPYqtVsgFIqLZlWq7Ud/zbZ+ZJ79x5J7t37ZCdwOd693Rjj+83mtzuBy5capdJycFWKiIjIOi42dMnQ63ipYM85TgPXsMHL0mShoGM+kQGwHSHLBeCzxph/eIP7/z3wI8aYo5vdv5MoZBERkd2os6/lJHaE2BHsc908oNZ1uaXUvn1H0wcPPhWKx9/eDRHazeYL1WLx4ysXLnwt6Ppeq1A0Go1ms+ORZHIiFIvZEV7h8IQTDo+7rmvHeLlu7nYeyxjTMr6/YHzfju9qtxf8ZrPYbjQWWrVasVmpFBul0rLxfV3BKHcksWfPwVQ3cIlEvO7txhjjN5vfaVYq51ZnZ79UX1lZDLJOEREReZUUkMYGLy5Qo7fb5SqdbpfJQkHTB0R2oO0IWX4V+MfAU8aYP9hw33uBZ7HjxP6bvh98mylkERGR3ayzr+VebGfLOHZm8EqgRcnASIyP78scPvz+cDL5bsdxIgB+q3WxtrT08eVC4Ys7MTgIx+OJaDY7Hk4kJsKx2LjbHeFld6DY/Seum7mdxzLGNEyn+6Q7vmt9gNJYXV1olMsr3MkBtcgdSIyP70vu2/dkJJU6HYpEXrf+vnaz+UJzdfVc5cqV52pLS8WgahQREZEbimNDlyx2xFgDWMUGLrP0QpdKYBWKyCu2I2QZAb4IPAD8NfDtzl0PAY8Cfwu8zRiz3PeDbzOFLCIiMgzynjeC3dfyIHZu8AxQDbQoGRixkZHR7LFj742kUj/iOE4CwG+35+rLy59cLhT+3N+mMVeRVCoVzWQmwolEb4F8L0AZ7+xASd7OYxljaqbdLnaXyPutVtFvNhfa9XqxVa0WG6urC83V1fJW/5tE7lR8bGxPav/+JyOp1JOhSOT+9fe1m80Xm5XKc5WrV5+rLSxcDapGERERuakItsslA8SwI55XgSJ2xFh3r0tpslDQRT0i22zLQ5bOF0kB/x3wfqDbtl4APgH8ayBmjFm6owffRgpZRERkmOQ9bz/2goh7sQfxM4BmAsttiaRSqZETJ94TTad/vNsNYnx/sV4qfXr5/PnPtmu12p0+djSTyUbS6YlwIjEeikYnQpHIuBMOT1wXoDhO7HYey/h+xfh+sbtEfn2A0qxWFxqlUrFVra7daa0iO00slxtLHzjwZCSVetKNRB50HMfp3uc3my8319bOVa5efa5aLM4FWaeIiIjcVIjeeLEEdtRzBVjChi5FbOiyNFko7LiOcpHdZltClht84TgwCXwU+GFjTPyuPfgWUcgiIiLDJu95LnACO0LsKNrXIn0KxWKx3MmTPxjLZt/nhEITAMb3Vxurq/mVixf/8LoOEMdxYtlsLpJKvRKguOGw3YHSWSLvuO54dxzZrRjfL3W7T0xngXy72Sy26/Via21toV4uL7yWsEdk0EWz2Vz64MG3RtPp024k8lB3rxKA32pdaFYq59auXTu3Nj8/E2SdIiIicksOdq9LpvPeBdawr9+mgWvY0GVxslBoBlWkyG61rSFL5yqp78cGK+/D/uAXgT8yxvy91/Tg20Ahi4iIDKu850WxHS2PAfuw+1qWg6xJBosTDodHPe+dsVzuA24odAjsGK52o/HXjutmO+O7xhzHCd3O4xnfX+p2n3R3oLQbjWK7Xl9orq0V66XSot9oNLb2XyWye0QzmWz64MG3RNPp0240+voNgcvl5traueq1a+cqV69eDrJOERERuW1JeqFLGKhhR4zNYl/PLQILk4WCLjoSeY22a1zY49hg5cPAfuzVr78D/DrwZTMgC0AVsoiIyLDLe14GeLjzlsJeFaV9LXLbHNd1R06efGtibOyDbjh8cuP9xhgf31/0O0vk/U4Hit9oFFu1WjdAWTLbtNtFZBhF0ulM5uDBN0UzmdNuNPqo4zjh7n1+qzXTqlbPrRWL5ypzcxeCrFNERET6EsOGLmkgCjSBMnZSwSydvS6ThcJqYBWKDKgtC1kcxzmJDVY+CtyDneP+u8BXO++fMsZ88g7rDoRCFhERESvvefuA1wP3YS+emEb7WqRP2WPHXh9JJo+0G43Fdq220KhUio1Sacn4vuZGi+wQ4WQylTl06E3RbPbJUDT6hvXj+vx2e661tvZcdWHh3Ors7MtB1ikiIiJ9C2NDlwwQx+7hXMWGLdOd94vAymShMBAXyIsEZUtCFsdxvgS8CTsK7OPAbxtjvti5zwNeQiGLiIjIQOvsazmG3ddyHHsV1BW0r0VEZFcKJxKJzOHDT0QzmSdDsdgbHceJdu/z2+35VrV6rraw8Fx5dvZ7DMi0AhEREXmFi+1yyWBHjQFUsGOip7DneReBpclCoR1EgSI71VaFLD5wAfgl7L6V1rr7FLKIiIjsInnPiwCvAx4H9tJbqigiIrtUKB6PZw4ffjyWzZ4OxWJPOI4T695n2u1is1Z7rra4eK48Pf1dBS4iIiIDycGOiO7udXGxo6JL2NCl+7pvcbJQ0C5EGWpbFbL8I+AjwJPYH7ZPYHewfA44iUIWERGRXSfveWngQewYsQx2VGgl0KJERGTLhaLRaObIkTfEstnToXj8TY7jJLr3Gd9fbFWrX6otLZ0rT0//rcYBioiIDLQEvb0uYaCBDV3msFMNuntdtLdThsqWLr53HOcEdifLR7Az268AZ4EPY0OWT91J0UFRyCIiInJrec/bAzyKfe53sPN8m0HWJCIi28ONRCKZI0cejY2MnA7HYm92XDfVvc/4/nKrWv1SbXn5XHlq6tsKXERERAZelN5elyh2T2cZ2+UyQ2+vy6r2ushutqUhy4Yv9Dg2cPlJ4ABwFcgDfwD8mTGmdscPvk0UsoiIiNyevOc5wFHsvpYT2I6WK4BOqImIDAknHA5njxx5fWxk5MlwPP4Wx3Uz3fuM75dbtdqX6svL50pTU98y7bZmu4uIiAy+MLbLJQvEsa//VoElrt/rsjJZKOi1oewa2xayrPuCLvAu4KeB92GTzjVjTPo1P/gWU8giIiLSn86+lnuAx4CDwDza1yIiMnScUCiUOXz44fjo6JPhePxJx3Wz3fuM76+26vWv1G2Hyzf9Vqt1s8cSERGRgeFi97lkgWTntjVgGTvxoLvXZWmyUNDzvwysbQ9ZNnzxOPBe4CPGmPfe1QffAgpZRERE7kze81LAA9h9LSNoX4uIyNByXNfNHD78YHx09HQ4kXjScd1c9z7j+2vtev0r9ZWV50rT08/7jYYW6YqIiOweDjZs6e51cYEa9nzrDL2L8hYnC4V6UEWK9CvQkGXQKGQRERF5bfKeN44NWh4AQtirl3QCTURkSDmu66YPHbo/MTbWDVzGuvcZY6rtWu1r9VLpufLU1NfbClxERER2ozi9vS5h7OvDMnbVxCw2dFmYLBTWAqtQ5BYUsvRBIYuIiMhr19nXchg7QswDqsAc2tciIjLcHMfJHDp0b9wGLqfdUGiie5cxpt6u17/eKJXOlaanv96u1Xb8Tk8RERG5I1Fsl0sGiAEt7F6XIvYivUVgAShPFgrDfbJadgyFLH1QyCIiInL35D0vDJwC3oDd17KAPXAWEREhfejQPYnx8W7gsq97uzGm0a7Xv9Eol8+Vp6e/1qpWdWWriIjI7hWiN14sib04r4INW6axryMXgOXJQkEX7kkgFLL0QSGLiIjI3Zf3vARwP7azJYftaikHWZOIiOws6QMHTiYmJk6Hk8m3uaHQge7txphWu9F4vlEun1udmflKs1LRvi8REZHdzQVS2NAl3bltDShhQ5fuXpelyUKhGUiFMnQUsvRBIYuIiMjWyXveKPAI8BB2Fu8MoGWHIiJyndT+/ccTExNPRpLJt7nh8OHu7caYtt9ofLOxuvpceWbmy83VVQX2IiIiwyFJr9slBNSwocsccAUbuixOFgoaNypbQiFLHxSyiIiIbK3OvpaD2BFiHnbp4SzQDrIuERHZmZJ79x5J7t17OpJMPumGw8e7txtjfL/Z/FZjdfW51ZmZLzXK5ZUAyxQREZHtFcOGLhnsBXwt7LSEq9jXl4vAwmShoA5YuSsUsvRBIYuIiMj2yHteCBuyvAE4jD0IvhZoUSIisqMl9+w5lNy798lIKnXaDYdPdm/vBC7faa6unludm/tSfWVlKcg6RUREZNtF6HW6xLF7XcrYnaDTdEIXoDRZKAz3CXC5IwpZ+qCQRUREZHvlPS8O3Ifd1zKObffWc7CIiNxUYmJifzdwCUUi93RvN8YYv9n822alYgOX5eWFIOsUERGRQITo7XRJAQZYBZaBKWz4sggsTxYKmqogt6SQpQ8KWURERIKR97wcdl/Lg9grj6axc3ZFRERuKj42tje1f/9bO4HLfevvazeb321WKucqV648V1tcVMekiIjIcHKwYUum894BqtgL/KaBeXp7XZpBFSk7l0KWPihkERERCVbe8w4CjwKvA5rADNrXIiIitymWy42nDxx4aySVOu1GIg84juN072s3my81K5Vza/Pzz1WLxStB1ikir+aEw+FYNjsWSaXGQ5FIdu3atRca5bLOzYjIVknQGzEWBurYEWNznbfuXhdd/CcKWfqhkEVERCR4ec9zgZPYEWLHsC3d89gWbxERkdsSGxkZTR848NZIOn3ajUQedBzH7d7nt1rnm5XKucr8/LnqtWuzQdYpMgzcaDQay2bHI8nkeCgWmwhFo+NuODzhhMMTruuOO6HQhOO6ufV/xxjTbjca36ivrPxF6dKlr/rNpq4uF5GtFAWy2NAlgr3Yr4TdHTpDL3RZDaxCCYxClj4oZBEREdk58p4Xw+5reQN2X8tVbOAiIiLSl2g2m0sfPPiWaDr9pBuJPLIhcLnYXFt7bm1+/tza/PxUkHWKDKJQPB6PZbPj4URiIhSLTYQikXE3EplwQqFx14YnE47rZm7nsYwxTeP7RYxpuuHw0Vdu9/1Kq1Y7V11Y+Ivy9PQLDPsJLBHZDmFsp0sGO9Lax3a6LGL3uiwCC0BpslDwgypStodClj4oZBEREdl58p6XBR7uvCWwVxFVAy1KREQGViSdzmQOHbKBSzT6qOM4oe59fqs11VxbO1ctFp+rXLlyMcAyRXaEcDKZimUy3QBl3I1EJtxweMINhbrdJ+OO66Zu57GMMXXTbheN7xf9drtoWq2FdrNZbNfrC61ardgol4vN1dVy988n9+49lNq370w4mTzjhkJ7urf77fbV5tra5ypXrpxVJ5qIbCMX2+WSwb4uBVjDnkueAorY0GVpslDQyOtdRiFLHxSyiIiI7Fx5z9uP3ddyL/YqommgFWRNIiIy2CKpVCp96NCbo5nM6VA0+pjjOOHufX67Pduygcu51bm580HWKbIVIul0JprJTITj8YlQLDYeikQmnHC4130SCo07jhO/nccyvr9mfL9o2u2i324v+K1W0e8GKNVqsV4uL7TW1ip3VKjjONkjRx6Mj42dCScSb3Mcp3tyk3az+WKzXD5bmp7+wvqARkRkGzhAkt5eFxd7MWAJe2HgPDZ0WZwsFBpBFSl3h0KWPihkERER2dk6+1qOY0eIHcMewF5F+1pEROQ1CicSyczhw09EM5nToVjsccdxIt37/Hb7aqtaPVddWDi3OjPzUpB1ityS4zjRTGYkmk5PhOPx8VAsZrtPwmHbfRIKjTuuO7H+e/xmjO+Xje8vdAKUot9qLfiNRrHVCVAa5fJCq1rdli7jUDQazR49+ubYyMgZNxp9Q3f0nzGm1W40/qq+vHy2dOnSV/1WSxfiiEgQEvS6XcJAAztibK7ztogNXdYCq1DuiEKWPihkERERGQx5z4tiO1oeA/aifS0iInIXhePxRObw4cej2ezpUCz2hOM40e59frt9rVWtPldbXDxXnpl5UbshZDs5rutGs9nRaCo1EYrHx0PR6IQbidgl8r3xXWPru7Juxvj+smm3F3zfL5pWa8FvtYrtRmOhXa8Xm2trxUaptNBuNHbkFdjRbDaXOXTo7dF0+owbiXjd243vr7ZqtS9Wi8W/KE9PfzfIGkVk6EWxoUu283ELG7oUsZMZFjtv5clCQccTO5hClj4oZBERERksec/LAA9h97WksW3ZuipIRETumlAsFsscPvx4LJt9MhSPP7F+VJHx/cVWtfpcdXHx3OrMzAvG97X4Vu6YEw6HY9nsaCSZnAjH4+NuNDrhhsOvBCiu607guqPd7o2bMcYYjFny2+3eCK9ms+g3mwutWq3YXFtbaKysLOyWjo/kvn1HU3v3nokkk+90QqHx7u1+uz3XrFTs/pZi8UqQNYqIYLtb1u918YFVYAm712UBG7osTxYKOqbYQRSy9EEhi4iIyGDKe95e7L6W+7Cjw2aAZpA1iYjI7uNGo9Hs4cOPxUZGngzFYm92XDfZvc/4/nKrWn2utrR0rjw9/R0FLrKeG4lEYiMj45Fk0u4/6QQoTij0yhJ5HCfnOI5zq8cyxrSN7y92dqDY/Set1kK70Si2a7Vis1JZqJdKS6bdHrrFy47rupkjRx6Kj42dCcfjp9fvlGk3my80yuWz5ampLzYrldUg6xQR6XCBFDZ0SXY+r2DPT08D17DBy9JkobArQvFBpZClDwpZREREBldnX8tR7L6W49grgq5irw4SERG5q9xwOJw5cuTRWC53OhyLvcVx3VT3PuP7K61a7Uu1paXnytPTfzOMJ7uHSSgWi8Wy2YlwMjkeisUmQpGIDVDCYRuguO6E47rZ23ksY0yru0B+Y4DSqlYXmpVKsVEuryjEu7VQLBbLHj36llg2e8aNRh+9bn9Lvf7V+vLy2ZXLl//K7JJuHhHZNVL0ul1coIbdRToLXKG316UeWIVDSCFLHxSyiIiIDL6850WA12HDlv3APPZAVEREZEs44XA4e/jww7Fc7nQ4Hn+r47qZ7n3G98utWu3L9ZWV50pTU3+tE7qDJZxIJKPZ7EQkkbAL5Dv7T7rdJ50AJXXrRwJjTMP4/jXTbi/47XbRtFrFdrPZC1BWV4uNclnnIrZAbGRkNH3o0Dui6fQZNxw+0b3d+H65Va1+oVosni3PzLwYZI0iIjcQp7fXJQw0sBcUXsEGL93QpRJYhUNAIUsfFLKIiIjsHnnPSwEPAq/HHpDOYFuvRUREtswr44pyudPhROKtjuvmuvcZ36+06vWv1FdWzpWnpr7pN5sabRmgSDqdiabT4+FEYuJVAYrrTjih0Pj6HTw3Y3x/7ZXxXe120W+1Fvxms9huNBZa1WqxUS4Xm5WKjkN2gNT+/ceTdn/LOxzXHeve7rfbs81K5ezq3NznagsLV4OsUUTkJiLYLpcMEAPa2NDlGnbE2CJ2xFh5slAY7pP9d5FClj4oZBEREdl98p43gd3Xcj/gYA88dVJLRES2nOO6bubw4Qfio6Onw4nEk47rjnbvM8ZU27XaV+ul0rnS1NQ3/EajEWStu4rjONFMZiSaTo+H4/GJUDQ67nZHeIVCE50OlHHHcaK383DG98vG9xc6C+RtgNJoFFv1ejdAWWhVq9Wt/mfJ3eW4rps9evSR+OjomVA8/qTjOLHufe1G4zuNcvlsaWrqXGttTeGYiOxkIXrjxRLYHaUVYAmYwgYuC8DyZKGgUZN3SCFLHxSyfe0ULQAAWXtJREFUiIiI7E55z3OAI8BjwEmgCsyhfS0iIrJdHMfJHD58X3xs7HQkHn/SCYUmuncZY2rtev3r9VLpXHlq6uvtel1z1m/AcV03ms3mIqnUxHUBSig07oTDNjyxAUr4dh7P+P6yabcXfN8vmlZrwW+1iu1GY6Fdrxeba2vFRqm00FYAtuuF4vF49ujRt8ay2TNuJPJ6x3EcAGNMs12vf6W2vHy2dOnSN7RfSUQGgIMNXdLY/S4uNnQpYS84vIYNXZYmCwVdfHibFLL0QSGLiIjI7pb3vDBwD3ZfywGgiD3AFBER2T6O42QOHnxdfHz8yXAicdoNhfZ27zLGNNr1+tcb5fJz5ampr7VqtaHpkHBCoVAsmx2NpFJ7wvH4uBuNTrjh8LgbDk84odCE67rjuO5Yd4H5zRhjDMYs+XaBfNFvtxf8ZrPoN5sLrVqt2FxbW2isrCz42pEjG8RyufH0wYPviKbT73LD4aPd243vr7Sq1S+sXbt2dnV29qUgaxQR6VMS2+mSwu51qWFHjM1id7ssYPe61AKrcIdTyNIHhSwiIiLDIe95SXr7WkawB5ergRYlIiJDK33w4KnE+PjpcDL5pBsKHejeboxpthuNbzRKpefKMzNfHeSxRW4kEolls2PhZHIiHI+Pu5HIRCgSsXtPQqEJNxQax3FGux0EN2OM8Y3vL3Z2oNjxXd0OlFqt2KxUivVSaUldB/JapQ4cOJncs6e7vyXXvd1vtaablcrZ1dnZs7WlpWKAJYqI3IkYNnRJY3e8tIAyME8neJksFOaCK2/nUcjSB4UsIiIiwyXveWPYoOUB7BU904BGgoiISGBSBw6cSE5MnA4nk6fdUOhQ93ZjTMtvNL7ZKJfPlWdmvtKsVHbMxQGhWCwWzWbHI8nkRCgWGw9195/YJfLdEV4jt/NYxphWd//JK0vkuwvka7Vic3V1oVEuLxvf18hP2TaO67rZY8cei+dyZ0Lx+FvW7/NpNxp/0yiXz5YuXz6n3TwiMqDC2NAlg+16mQF+e7JQGO6wYB2FLH1QyCIiIjJ8OvtaDgOPAqfQvhYREdkhUvv2HU3s2XM6kkyevm5skTFtv9H4VmN19dzq7OyXG+Xylr1+DScSiWgmMxFJJsdDsdhEd4G8axfIjzuuO+G4bvp2HssY03il+6TdXjCtVrHdbNol8tVqsbG6utBYXS0x7CcnZEcLJxKJ7JEjT0az2TOhaPSR7u3GmEa7VvtyZ3/L8woCRWRATQBt4LcmCwX9HutQyNIHhSwiIiLDq7OvxcPuazmEnUur8Q8iIrIjJPfuPZzcs+fJSCp12g2HT3RvN8b4frP57U7g8qVGqbR8u48ZSaXS0UxmIpxIjIei0Qk3Ehl3w+EJt7tAPhSacBwncTuPZYypmna7aHx/wW+1in6rVfSbzYW2DVAWGuVycSd134jcDfHR0Yn0wYPvjKRSZ9xw+Ej3duP7y821tc+vXbt2tjI3dz7IGkVE+qSQZRMKWfqgkEVERETynpcA7gceA0axM2nLgRYlIiKyTmJi4kBq374nI8nkaTcSOdW93Rhj/GbzO81K5dzatWvfCEUiiXAiMeFGoxOhSKQ7vsuGJ647sX7k0c0Y31/tdKDY8V2t1oLfbBbb9bpdIF8uFzUmSYZd+uDBU4k9e85EEom3rx+P57dal5uVytnyzMzn6svLC0HWKCJyGxSybEIhSx8UsoiIiEhX3vNGgUeAB4Eodl9LPdCiRERENoiPj+9L7dv3ZCSVejIUidzb7983vr9ifH/Bb7eLxnagLLRtgLLQXFsrNkqlhXa9ruc/kdvkhEKh7NGjb4iPjp4JxWJvdhwnAq+EoN+ql0pny5cvf6lVqymYFJGdSCHLJhSy9EEhi4iIiGyU97xD2K6WU0AD29nSDrQoERGRTcRHRydS+/c/GUmnT7vh8OswZsVvt19ZIt9uNot+s1ls1WoLrbW1Yr1UWvSbzWbQdYvsVuFkMpU9cuTJaCZzJhSNPtS93RhTb9dqX6otLf1F6fLlb2l/i4jsIApZNqGQpQ8KWURERGQzec8LASex+1qOAEvAfKBFiYiIiMjAiI+N7U0fOPDOSDp9xg2FDnVvN76/2Fxb+/za/PzZypUrFwMsUUQEFLJsSiFLHxSyiIiIyM3kPS8O3IftbBkH5gAdM4iIiIjIbUsfOvS65MTEmbDd35Lp3u63Whcbq6tnV2dmPl9fWVkMskYRGVoKWTahkKUPCllERETkduQ9b4TevpYEdl9LLdCiRERERGSgOOFweOTo0cdjudyZUCz2JsdxwgDGGN9vNP66XiqdLV2+/CXtRRKRbaSQZRMKWfqgkEVERET6kfe8A8CjwOuAFnZfSyvImkRERERk8ERSqVTmyJHvi2YyZ0KRyP3d240xtVat9lxtcfFseWrqb7S/RUS2mEKWTShk6YNCFhEREelX3vNc4AR2X8tR7LHEPDDcB1YiIiIickcSExP7U/v3vzOSSp1xQ6ED3dtNu73QXFv73Nr8/NnK1auXg6xRRHYthSybUMjSB4UsIiIicqfynhcD7sXua9kLXAGWg6xJRERERAZb5vDh+xLj42fCicT3Oa6b7t7ut1rnG6urZ8vT059vlErLAZYoIruLQpZNKGTpg0IWERERea3ynpcFHgIeBlLYfS3VQIsSERERkYHmhsPh7LFjT8RGRs6EYrE3btjf8ny9VDpbunTpy+1GoxF0rSIy0BSybEIhSx8UsoiIiMjdkve8fdh9LfdiR4dNo30tIoPCAeLYoLQGrAZbjoiISE8knc5kDh/u7m+5t3u7MabaqlbP1RYXz5ampr7NsJ/oE5E7oZBlEwpZ+qCQRURERO6mzr6W49gRYseBMnaM2HAfdInsPAlsoJICop3b1jpvCSAN1IFF7M+xiIjIjpDYs+dgat++7v6Wfd3b/Xb7Wmtt7XOVq1fPrs3PTwdZo4gMFIUsm1DI0geFLCIiIrIV8p4XBV4HvAHYB1wFlgItSmR4dTtUUkCsc1sVG6hc7bytYHcqlYAscAA42XmfARrYwEWvGUREZGdwHCdz+PD9ifHxM+F4/G2O66a6d/nN5kud/S1faJTLK0GWKSI7nkKWTShk6YNCFhEREdlKec9LY/e1PIK9Mn4Ge2JXRLZGjF6gEu/cVseO/7qG7SzrBiork4XCDUf65T3PAXLYoOUEcIhe4LKEDVyG+wWViIjsCG4kEskeO/am2MjImVA0+rjjOCGw+1vajcZf1VdWzpYuXfqK32w2g65VRHYchSybUMjSB4UsIiIish3ynrcHu6/lvs5NM4Be5Iq8NlF6gUoCu1elBlSwgcpVbJiyjA1UXtPPXN7zRoCD2FGAh7EdL01s4LKCAhcREdkBoplMNnP48Nsj6fSZUCRyT/d24/uVVq12rrqwcLY8Pf232t8iIh0KWTahkKUPCllERERku3Suij+G3ddyErvn4SqgA1mRW4twfaDiYjtUKtgxXrNcH6g0trKYvOdlsYHLMeAIMAK06I0U08+1iIgELrl376HUvn1nwsnkGTcU2tO93W+3rzbX1j5XuXLlbPXatdkgaxSRwClk2YRClj4oZBEREZHtlve8CHAPNmw5gL3ifjHQokR2ljB2vF6y8+ZiR3R1A5U5et0jy5OFQj2gOgHIe14G+7N8HDhKL3Dp1qgXqyIiEizHcbJHjjwYHxs7E04k3uY4TqJ7V7vZfLFZLp8tTU9/obm6Wg6yTBEJhEKWTShk6YNCFhEREQlK3vNSwIPA67Fjh2awJ5FFhkkYG6R0u1Rc7AiuCjak6AYqy9hApRZMmbens4fpALbD5Sh2p4tP79+gF64iIhKoUDQazR49+ubYyMgZNxp9g+M4LoAxpt1uNL5eX14+W7p06at+q3XDvWUisqsoZNmEQpY+KGQRERGRoOU9bwIbtNwPhIBp7FX7IrtNCBuodLtUXOwLugo2gJjDdqosY0d+rQVS5V3SCVIPYMeJHQdG6QUuK9h/u4iISGCi2Wwuc+jQ26Pp9Bk3EvG6t3f2t3yhWiyeLU9PvxBkjSKy5RSybEIhSx8UsoiIiMhO0NnXcgQ7QswD1rAnnHWQK4PKpdedksQGLN1ApYT9/l6gN/JrV3dx5T0viQ1cDmN3MuU6dy1jQxcFLiIiEqjkvn1HU3v3nokkk+9wQqGJ7u1+uz3XrFTs/pZi8UqQNYrIllDIsgmFLH1QyCIiIiI7Sd7zwsAp4A3YpdoLQDHQokRuzeX6kV8hwNALVGZZF6gAlclCYWhfiOQ9L8H1gcto567lzpvGs4iISGAc13UzR448FB8bOxOOx5/csL/lhUa5fLY8NfXFZqWyGmSdInLXKGTZhEKWPihkERERkZ2oc9X7/djOlhx2X4teyMpO4HB9oBLBdlxVgDK9DpXlztvqMAcqt5L3vDiwH9vJ1g1cHOxrlCUUuIiISIBCsVgse/ToW2LZ7Bk3Gn103f6WVrte/2p9efnsyuXLf2W0v0VkkClk2YRClj4oZBEREZGdLO95Y8AjwIPYBeHa1yLbyQES9AKVKDZQWcOGfleAa1wfqOiF2R3Ke14MG7h0O1zGsF1B3cClGVx1IiIy7GIjI6PpQ4feEU2nz7jh8Inu7cb3y61q1e5vmZl5McgaReSOKGTZhEKWPihkERERkZ2us6/lELar5RRQw45f0gGw3G3rA5UY9nusig1UrgLz9EZ+lfQibOvkPS+KDVwOYfc0jWOD1m7gorBVREQCk9q//3iyu7/Fdce6t/vt9myzUjm7Ojf3udrCwtUgaxSR26aQZRMKWfqgkEVEREQGRd7zQtiQ5THsiddFtK9F7lycXqASxwYqNezYr40dKqXJQkGL2QOS97wINnA5iP0dMI4d01bC/h5Q4CIiIoHo7G95JDE2diZk97fEuve1G43vNMrls6WpqXOttbVKkHWKyE0pZNmEQpY+KGQRERGRQdPZ4dDd1zKK3YFRDrQo2eli2DAl3fkYeoHKNWyoskwvUNFc9R2qE7js4/rAJYr9HbAI1IOrTkREhlkoHo9njx59ayybPeNGIq93HMcBMMY02/X6V2rLy2dLly59w7TbunBDZGdRyLIJhSx9UMgiIiIigyrveTnsvpaHsCdZp9EJVrHfC2nscvpE57Y6rw5UVoCVyUJBez4GVN7zwtjA5QA2cNlDL3BZwgZpIiIi2y6Wy42nDx58RzSdfpcbDh/t3m58f6VVrX5h7dq1s6uzsy8FWaOIvEIhyyYUsvRBIYuIiIgMurznHcR2tdyDXYw9gz1Ilt0vig1TUp33Dr1ApYjtcuruUFmZLBQ0VmqX6owT3Euvw2UPtmtpFRu4VIOrTkREhlnqwIGTyT17uvtbct3b/VZrulmpnF2dnT1bW1rSCFyR4Chk2YRClj4oZBEREZHdoHOC9SQ2bDmCPb6ZB4b7YG93idDboZIAXOwuju5J9Fl6I79WJgsFdTUNqc7vgz3YwMXDhi8J7PfKIgpcREQkAI7rutljxx6L53JnQvH4WxzHiXbvazcaf9Mol8+WLl8+16pW9Twlsr0UsmxCIUsfFLKIiIjIbtLZ13Iv8AbsroYr2GMdGSxheoFKkl6gUsGGKLPYYGUFWJ4sFDQWSjaV9zwXG7h0R4rtoxe4LAFrwVUnIiLDKpxIJLJHjjwZzWbPhKLRR7q3G2Ma7Vrty539Lc8b39cJX5Gtp5BlEwpZ+qCQRURERHajvOeNYPe1PIg9oTqDrl7fqUJcH6iEgBa9QGWG6wMV/X+UO9IJXCboBS57sd9zVWyHSyW46kREZFjFR0cn0gcPvjOSSp1xw+Ej3duN7y8319Y+X7127ezq3Nz5IGsU2eUUsmxCIUsfFLKIiIjIbpb3vP3Ao9juljb2hH0ryJqGnEsvUEl1Pm9jT26v0OtQWcYGKuoykC3RCVzGsYGLh+1wSdMLXFaDq05ERP7/7d15nGTXXd/9z6nep6dnRrNo9tFyNRpJlix5w9aMHSyTPDwhKVYDCasTwmIwweGBsAUMCTGEsAUcHshDsHCcYMwSQ0GIY7Bk8IxledHIsnZdbbOPZunpfa3z/HFuuWta1aPptXr5vF+v+6rpu9T9VfXpO933W+ectWr9rl03dW3bdk9bV9ffC6XSxtr66sTEi+ODg/f1nzhx/2hv7/lm1iitQoYsDRiyzIIhiyRJWu2Km6k3kIYQ24fztSyVElOT0neTeqhUSYFKPylQOc/UPCpD5Tz3e6IlV8myAGxmag6XHaQ2O0IK/fqbV50kaS0KLS0tG/bte23nNdfc09LR8cYQQhtAjDFWx8e/MNrXd1//iy9+amJkxB6+0vwZsjRgyDILhiySJGmtqGRZO6lHy2tIwwSdId3c1/yVSMOyrScFK22kP1SGeHmgcgkYMFDRclQELteQApcbisf1wCiph4uBiyRpSbWuW9e9Ye/eg+09Pfe0tLffXlsfYxydHBn51MjFi/f1vfjiw87fIs2ZIUsDhiyzYMgiSZLWmkqW9QB3FEs3cBzna5mNQApSar1U2kk9VGqByiku76Ey4B8rWomKwGUTlwcuPcAYU4HL2v6DUpK0pDo3b752/c6db21bv/6eUkvL7tr6WK1eGB8a+sTQ2bP3DZ4+/XwTS5RWIkOWBgxZZsGQRZIkrVWVLNsO3AncQrpRehzna5kuAJ2kMGU9qYdKJIVSA6TeQGeZClT6/cNEq1UlyzaR5nC5AdgNbADGSYFLHwYukqQltH737pvXbd16T2uav6Wntr46MfH82MDAfQMnTnxi9NKlC82sUVohDFkaMGSZBUMWSZK0lhXztVxHGkLsBtIn00+zdm+WdpEClXWkcCWSeqgMcnmgcgnoK+f5ZHPKlJqrkmUbSYHL9cAeUuAySQpcLrF2ryGSpCUWWltbN+7b97qOTZvuaeno+LIQQitAjLFaHRt7eLSv776+F1/81OTo6Giza5WWKUOWBgxZZsGQRZIkCSpZ1gbcDLwW2A68RLpZupp1ksKU9UBHsW6EqUDlDOn3xF7gkoGK1FglyzaQApfrgH1MBS4XST9D/rEuSVoSbd3d3T17976lvafnnpa2tltr62OMIxMjI0dGLly4r//YsUecv0W6jCFLA4Yss2DIIkmSNKWSZeuBV5GGEesBTpBCh5Wug9RDpZsUrgRSoDJACpROc3mg4rBp0hwUcz7tJIUt1wEbSX+09xaLf7hLkpZE19atO7p37HhrW3f3PaWWlp219XFy8vz40ND9Q2fP3jd45syLzaxRWiYMWRowZJkFQxZJkqSXq2TZNuAu0nwtgTRfy3gza5qFdi4PVEpM9VA5T5qYvpciVCnn+Up5XdKKUsmybmAXsJc0rNhG0jBiFzFwkSQtoZ49ew50bdnyttaurreEUml9bX11YuLZsYGB+/qPH//EWF9fbxNLlJrJkKUBQ5ZZMGSRJElqrJJlgfRp9NeS5msZJPX4WE6/eLcxFah0kQKVUVKtF4CTXB6ojDWnTGltq2TZOlIPl72k68kmUuDSWywOxydJWnSl1tbWDddd94aOjRvvaenoeP20+VseGu3ru6/vhRcemBwb83dGrSWGLA0YssyCIYskSdKVFfO17AdeQ/pU+lmaM19LK1OByjpSoDLGVKBS66HSSxrya6QJNUp6BZUs6yIFLnuAG4Frik29pF4uBi6SpEXXtn59T8+ePbX5Ww7U1scYhyeGhw+PXLhwX9+xY19krd881VpgyNKAIcssGLJIkiRdnWLon9tI87VsZHHna2klBSm1UKVEGq5skHQj9iRTQw71GqhIK1Mlyzq5PHDZXGzqLRbnR5IkLbqurVt3du/YcU8xf8v22vrq5OS5iaGh+wbPnLlv6OzZ482sUVpEhiwNGLLMgiGLJEnS7FSybAspaLkNaCHN1zKfIRVaSIHKetKQXy2kX/JrgcopUk+VXlIPlaF5nEvSMlXJsg5S4LIbyEg9XFpIf69dwMBFkrQEevbuvbVry5a3tXZ2vjmUSt219dXx8aeL+Vv+bqy//1Iza5QWmCFLA4Yss2DIIkmSNHvFfC17SEOIZcAwKQx5pV/KS0wN99XNVKAyRPqd7BRpcvpLpFBlqJzna/sXVmkNqmRZO7CDdJ3JSD1cWoA+UuAy3rzqJC2QNqAD6CweO0g/26cwVNUyUGpra9uwb98bOjZteltLe/vrQggtkOZvmRwb+9zopUv39b3wwqer4+P+n6SVzpClAUOWWTBkkSRJmrtKlrUCNwGvJc3Xch44V2wukXqmrGcqUImkHip9pCG/aj1UeoFBAxVJ0xWBy3amerhsZSpwucj8etJJWjwBaGcqROksvi6Rfh8YB0aBEdJ9mYukn/V9wABwmlf+8Ia0JNp7ejb07Nnz99rWr7+npa1tf219rFaHJkZGPjl8/vx9/cePP+b8LVqhDFkaMGSZBUMWSZKk+Ssmsr6V1LNlM+mmSJUUqPSTbpScoxjyC+g3UJE0W5UsayPdhN1FCni3kj4NX+vhYuAiLa0SUwFKLUxpJ4UokfQzOUrq8XqxWAZIvx8M1R7LeT4JXwpV9wN3kYYP7AXOFs8lLQvrrr12d/f27fe0rlt3T6mlZVttfZycPD8+MnJk5MKFwwMnTjwRq1VvVmulMGRpwJBlFgxZJEmSFk4ly64hfdJ8jMsDFX9Zl7Sgip5020k3YveTbhC0k4LdC6Qbu5Lmr5XLe6N0FOsgDes1WiyDTAUpXwpQisfh2Xy4ovjwxgFS2LKNFLRcmP9LkRZQCGHD3r2v6ty8+Z7Wzs5DoVRaV9sUq9WLE8PDnxq5ePFw//Hjjxq4aJkzZGnAkGUWDFkkSZIkaWUrApdruTxw6SB9Yv4CaTgiSTObPqxXJ2m4L5jqjTJK6jV2nhRmTu+NsuDBZiXLeoDbgDuAjaSesd670bJTamtr69m7966OjRsPtXZ0vDGUSt21bbFavTQxMlILXL4YJycnm1mr1IAhSwMrPmQJIfwA8KOkiQ4fBn4wxvjgVRz3T4A/AP4sxvi1V3kuQxZJkiRJWiUqWdbCVOByE+lT8J2kG8EXSMMWSWtNbViv+t4o7XXbayHKCKknygXSz0xtGSIFKU2ZkL6SZZuB20mByzrSvG6DzahFeiWhtbV1w969d3Zs3HiwtbPzTaFU6qlti9Vq/8TIyAOjvb2H+44f/0KcmGjKz5Q0jSFLAys6ZAkhfDPwAeD7gE8D7wa+ETgQYzx7heOuBz4JPAtcMGSRJEmSpLWtkmUlpgKXjDS8mIGLVqtWLg9SOoEWUo+USaZClGFSb5RepvVGIQ3rtWxvsFWybAepV8sB0ms7gUMDahkLLS0tPXv23NF5zTUHWzs77w6l0sbatlitDk6Mjj4w2tt7pP/YsYeqBi5qHkOWBlZ6yPJp4DMxxncVX5eAY8Bvxhh/cYZjWoC/BX4PeAuwyZBFkiRJklRTBC5bgV2kHi7XAl2kG8sX8VPxWhnaubw3SieplwrAOClEGWVqbqI+Lu+NMrgYw3otpUqWBWAPcCcpPK2SwpbxZtYlvZJQKpV69ux5Vec11xxq7eq6O5RK19S2xWp1aHJ09MHRS5cO9x0//lB1bGysmbVqzTFkaWDFhiwhhHbSf/pvjzF+pG7975OCk6+Z4bifA14dY/y6EMK9XCFkCSHUPtVR0wMcx5BFkiRJktaEInDZQgpcbiQNVd1N+nu0NkyS1Az1w3rVQpQ2Um+UyFSQMkLqiXKRFKjUeqPU5kdZ9Z+IL36ObyCFLdeReuicJt0olJa1UCqV1u/efUvn5s2H2jo7D4aWli21bTHGkcnR0c+MXrp0uP/48c9Njo6u6GBUK4IhSwMrOWTZRfr0wcEY46fq1v8S8OUxxjc2OObNwIeAu2KM564iZPlZ4D0NNhmySJIkSdIaU3wqfgtTQ4rtANaTbtheAAaaV51WqRameqLUBymQemXUeqPUelld4PIhvQZZ5sN6LaVKlrWRfnbvIvVwuQScIYVS0vIXQujZvfvmzs2bD7V2dR0qtbRsq22KMY5Njo5+dqyv73D/8eOfnRgZcZhLLQZDlgbWTMgSQugBvgB8f4zxr4p192JPFkmSJEnSLBWBy2ZS4HJj8biedMP7AqnHgHQ1asN61QcpLaQb/5NM9UYZILWtS0zrjQKMlvN8+dy0WeYqWdYJ3EwKW64lzTtzrpk1SXOxfteu/V1bthxsXbfuUKmlZUdtfYxxfHJs7PNF4PLgxPDwUDPr1KpiyNLASg5ZZjVcWAjhLuAhLu8KWhuLtAociDHmr3BO52SRJEmSJF2mCFyuIQUtN5CGFusBxpia60JrV+DyuVE6SMFKKLaPMTXR/CXSDf8Bpk00X85z5xFZYJUs6wZuIYUt15B6tfQ2sSRpzrp37rxx3datB1vXrXtzqaVlV219jHFicmzsobH+/iMDJ058enxw0F6Xmg9DlgZWbMgCX5r4/sEY4w8WX5eAF4H3TZ/4PoTQSZqwsN7Pk37x/SHgqRjjFSeKMmSRJEmSJL2SSpZtIgUtNwC7mQpcLpICl+X1x7UWQguNg5Ta97rWG2WYmYf1GvKGVXMUP7OvKpYe4CQO/6cVrHvHjuu6tm491LZu3cFSa+u+2voY42R1bOzhsYGBw/0nTjwwPjBgr0vNliFLAys9ZPlm4PeB7wUeBN4NfBNwS4zxTAjhA8CJGONPzHD8vVxhuLAG+xuySJIkSZKuWiXLNpJ6uFwP7AU2kCYkv0j6+3J5/aGtK2nj8hClgxSuBGCCqd4oA6Tvby/TQhRgxGG9lq9Klm0D7gBuJYVkJ0jBmLRirbv22r3rrr32YNu6dYdKra3X19bHGKvV8fFHxgYGDg+cPPnAWF9fb/Oq1ApiyNLAig5ZAEII7wJ+lDTh4FHgX8YYP11sux94Psb4jhmOvRdDFkmSJEnSEqhk2QZS4HIdsA/YSLo5XxtSzJsVzRVIN9Y7mQpT6of1GmdqovlLTM29Ux+kDDqs18pWDP+3ixS23FysPkHqjSataF3btu3qrgUubW1ZbX0RuDw2Pjh4eODkyU+NXrp0oZl1alkzZGlgxYcsS8mQRZIkSZK0ECpZ1sPlgcsmUuBS6+HijYvFUWIqQKk9tpGClCrpRvoIKTSpBSkDXN4bZaic55Mve2atKpUsK5F+Nu8EbiS1jZOkn1NpxevasmX7uu3bD7V1dx9qaWvbX1sfY4zViYnHxwcGDg+ePv2pkYsXzzWzTi07hiwNGLLMgiGLJEmSJGmhVbJsPSlw2UcKXTaShhGrDTnlTYzZaeXlQcr0Yb1GefmwXvU9UhzWSwBUsqyVFLLcSfoZ7QfO4M+lVpHOzZu3de/YcbAIXG6p3zY5Pv7k+ODg4cHTp4+MXLhwtlk1atkwZGnAkGUWDFkkSZIkSYupkmXdpMBlL2kel01MBS6XSDc21rrasF7TJ5qvH9arFqT0kt67PqZNNF/Oc4d/0lWrZFk7sB+4i/QzehF4CedV0irTsWnTlvU7d97d1t19qNTWdlsIoXZtpTo+/vT40NCRwTNnjgyfO3eqmXWqaQxZGjBkmQVDFkmSJEnSUqlk2TrS/KN7SZ+k31Rs6iXd4F3NgUuJqfCkNkdKW7EtkoZuGiVNSn6xWAaYNtG8w3ppoRU/lwdIYcsWUtDi/BValTo2bryme+fOu9vXrz9Yamu7PYRQqm2rTkw8Oz44eGTo7NnDQy+9dKKZdWpJGbI0YMgyC4YskiRJkqRmqGRZJ1M9XG4ANhebeotlJc4T0crlvVE6ScN6QRqKqTbJ/CBTQcplvVGAYYf1UjNUsmwDcBtwB2mIv1OkHlPSqtTe07Nx/a5db2rv6TlUamt79bTA5YXxoaHDQy+9dGTozJkXm1mnFp0hSwOGLLNgyCJJkiRJarYicKn1cKkFLoH09+pFllfg0s7L50cpkXqj1A/r1QecJ813Mb03yujSly1dnUqWbQFuB24FuoCTpPYrrVpt69f39Oze/cb29esPldrb7wwhtNa2VScmjo8PDx8efumlw4OnTz/fxDK1OAxZGjBkmQVDFkmSJEnSclLJsg5S4LIbyEiBSwtTgcv4IpdQP6xXLUhpr9teC1FGinouMDXJfC1MGSrn+XIKhqRZq2TZDuDVpKHESsAJUtuXVrW27u7u9bt3f1l7T8+hlvb2114WuExOnpoYGjo8fP784YGTJ/Nm1qkFY8jSgCHLLBiySJIkSZKWq2Ji7h3ALuAm0nwRrUwFLnOd6L02rFd9b5TaTbQqUyHKMKk3Si/TeqOQhvXyZoxWtUqWBVIPsztJoecEKWwxRNSa0NrV1dWzZ88b2nt6DrV0dLwuhPCl0L06OXlmYnj4yPD584cHTpx4qpl1al4MWRowZJkFQxZJkiRJ0kpQybI2Xh64tJGG5brAywOXdl4epNTG259gan6U/uL4Pi7vjTLosF5SUsmyFuB64C7gOtLPyClSKCmtCS2dnZ09e/a8vmPDhoMtHR1vCCF01LZVJyfPTQwPHx65cOFI/4kTT7DWbzqvLIYsDRiyzIIhiyRJkiRppSkCl2tJQ4rVApd20g3fwNT8KCPFcokUpAzw8iDFT+RLV6n42buJFLbsJvXyOkv6mZPWjJb29vaevXtf17Fhw6GWzs43hBC6attitXphYnj4yPCFC4cHTpx4PFar3rhf3gxZGjBkmQVDFkmSJEnSSlbJslZS4LKTNHdL/bBegzisl7TgKlnWSZqr5U5gO/ASaWg9ac0ptbW1bdi79zXtGzceau3oeGMoldbVtsVqtXdiePjISG/vkf5jx75o4LIsGbI0YMgyC4YskiRJkiRJmotKlq0HbiWFLZuAM6TeLdKaVGptbe3Zu/fOjo0bD7V2dr4plErra9titdo3MTLyqdHe3sN9x449EicnJ5tZq77EkKUBQ5ZZMGSRJEmSJEnSfFSy7BrgduA2YD1wkjQ8n7RmhZaWlg179766Y9OmQ62dnXeHUqmnti1WqwMTIyMPjF66dLjv2LGH48SEQ1c2jyFLA4Yss2DIIkmSJEmSpIVQybJrgTuAW4A2Utgy3NSipGUglEqlnr17b+/ctOlQa1fX3aFU2lTbFqvVwYnR0QfHUuDyUHV8fLyJpa5FhiwNGLLMgiGLJEmSJEmSFkolywKwizSE2E1AJIUtY82sS1ouQqlU6tmz57bOa6452NrVdTCUSptr22KMw5MjI58Z7es73H/s2Ocmx8b8uVl8hiwNGLLMgiGLJEmSJEmSFloly0rAdcBdwPXAKClscR4KqSaE0LN79y2dmzcfbOvqOhRaWrbWNsUYRydHRz8z2td3pP/48c9OjoyMNLPUVcyQpQFDllkwZJEkSZIkSdJiqWRZK5CRwpY9QD9wBvBmplQvhLB+1679XVu2HGrt6jpYamnZXtsUYxybHB393Fh//+H+48c/MzE87DB8C8eQpQFDllkwZJEkSZIkSdJiq2RZB7CfNIzYTuAC8FJTi5KWsfW7dmVdW7Ycal237lCppWVnbX2McWJybOzzReDy4MTQ0GAz61wFDFkaMGSZBUMWSZIkSZIkLZVKlq0DbiGFLVtJvVouNrUoaZnr3rHj+q5t2w61dXW9udTauru2PsY4UR0be3hsYOBw//HjD4wPDg40s84VypClAUOWWTBkkSRJkiRJ0lKrZNlG4FXA7UAPcIo0lJikK1i3ffu+ddu2HWxbt+5QqbX1utr6GONkdWzsC2MDA4cHTp58YKy/33u9V8eQpQFDllkwZJEkSZIkSVKzVLJsKylouRXoBE4AzjchXYV11167e922bYfaursPllpbb6ytjzFWq+PjXywCl0+N9fX1NrHM5c6QpQFDllkwZJEkSZIkSVKzVbJsJ/Bq4GagBBwHxppalLSCdG3durN7+/aDbevWHSy1te2vrY8xxur4+KPjg4NHBk6dOjLa23uhmXUuQ4YsDRiyzIIhiyRJkiRJkpaDSpYFYB8pbMmAceAkMNHMuqSVpnPLlu3d27ff3dbdfailre1A/bbJ8fHHxwcHjwyeOnV45OLFc82qcRkxZGnAkGUWDFkkSZIkSZK0nFSyrAW4AbgLuA4YJM3Z4g1QaZY6r7lma/eOHXe3rV9/qNTaemsIIdS2TY6PPzU+OHh46MyZI8Pnz59pZp1NZMjSgCHLLBiySJIkSZIkaTmqZFkbsJ8UtuwCeoGzwNq+oSfNUcfGjZvX79p1d1t396FSW9ur6gOX6vh4Pj40dHjwzJnDw+fOnWpmnUvMkKUBQ5ZZMGSRJEmSJEnSclbJsi7SXC13AduAlwDnlZDmoX3Dhk3rd+16U/v69YdKbW13hBBKtW3ViYnnx4eGDg+dPXt46OzZ482scwkYsjRgyDILhiySJEmSJElaCSpZ1gPcSpqzZRNwmnRfS9I8tPf0bFi/a9cb29evP1Rqb78zhNBS21admHhxfGjoyPC5c4cHT59+oZl1LhJDlgYMWWbBkEWSJEmSJEkrSSXLNgO3A7cB64CTpHlbJM1TW3f3+vW7d7+xvafnYEt7+2tCCK21bdWJiRMTw8OHh86dOzx46tRzzaxzARmyNGDIMguGLJIkSZIkSVqJKlm2ndSr5WaglRS2jDS1KGkVaV23rrtn9+43tG/YcKilvf21IYS22rbq5OSpiaGhI8Pnzx8eOHnymWbWOU+GLA0YssyCIYskSZIkSZJWqkqWBWA3ab6WDKgCJ4DxJpYlrTqtnZ1dPXv2vL59w4ZDLR0drw8htNe2VScnz04MDx8eOX/+SP/Jk0+xsm66G7I0YMgyC4YskiRJkiRJWukqWVYCrgfuBG4AhoFTpJunkhZQS0dHR8+ePa/r2LjxUEtHxxtCCJ21bXFy8tz4yMiRkQsXDvcfP/7ECghcDFkaMGSZBUMWSZIkSZIkrRaVLGsj9Wi5i9TDpR84Q+rhImmBldrb2zfs2fOajo0bD7V0dr4xhNBV2xar1QsTw8OfGrl48XD/8eOPxWp1Of4cGrI0YMgyC4YskiRJkiRJWm0qWdZBmqvlLmAHcK5YJC2SUltbW8+ePXd1bNp0sLWj402hVOqubYvVau/EyMgDIxcvHu4/duyRZRS4GLI0YMgyC4YskiRJkiRJWq0qWdYN3EIaRmwzqVdLbzNrktaC0NraumHPnld3bNp0qLWz802hVOqpbYvVav/EyMgDo729h/uOH/9CnJiYaGKphiwNGLLMgiGLJEmSJEmSVrtKlm0EXgXcDvSQ5mvpb2pR0hoRWlpaevbsub3zmmsOtXZ23h1KpY21bbFaHZwYHX1gtLf3SP+xYw9Vlz5wMWRpwJBlFgxZJEmSJEmStFZUsmwbKWi5FegATgDDTS1KWkNCqVTq2bPnts5rrnlza1fX3aFUuqa2LVarQ5Ojow+OXrp0uO/48YeqY2NjS1CSIUsDhiyzYMgiSZIkSZKktaSSZQHYCbyaNG8LpLBlKW7oSiqEUqm0fvfuWzo3bz7U1tl5MLS0bKltizGOTI6Ofmb00qXD/cePf25ydHR0kcowZGnAkGUWDFkkSZIkSZK0FlWyrATsI83XcgMwDpwEmjk/hLQ2hRB6du++uXPz5kOtXV2HSi0t22qbYoxjk6Ojnx3r6/tk//Hjn5sYGVnI3meGLA0YssyCIYskSZIkSZLWskqWtQA3AneRQpcB4DTgDVepSdbv2rW/a8uWg63r1h0qtbTsqK0vApfPj/X3H+4/fvwzE8PDQ/M8lSFLA4Yss2DIIkmSJEmSJEEly9qB/aSwZSdwEXgJWNs3EKUm696588Z1W7cebF237s2llpZdtfUxxonJsbGHxvr7Dw+cOPHp8cHBwTk8vSFLA4Yss2DIIkmSJEmSJE2pZFkXcAB4DekG7FngQlOLkgRA944d13Vt3Xqobd26g6XW1n219THGyerY2NGxgYEj/SdOPDA+MNB/lU9pyNKAIcssGLJIkiRJkiRJL1fJsg3ArcAdwEbSEGLeP5OWiXXXXrt33bXXHmxbt+5QqbX1+tr6GGO1Oj7+hbGBgSMDJ08+MNbX13uFpzFkacCQZRYMWSRJkiRJkqSZVbJsM3A7cBuwDjgJzGVYIkmLpGvbtl3dtcClrS2rrS8Cl0fHBwYOD5w69cDopUvTe6UZsjRgyDILhiySJEmSJEnSK6tk2Q5Sr5ZbgBJwAhhtalGSXqZry5bt67ZvP9jW3X2opa3t5tr6GGOsTkw8Pj4wcHjw9OlPjVy8eA5DloYMWWbBkEWSJEmSJEm6OpUsC8Ae4C7gRqBKClvGm1iWpBl0bt68rXvHjoNt3d0HW9rabq3fNjk+/uRYX9/RwTNnHhzt7f11Q5YphiyzYMgiSZIkSZIkzU4ly1qA64E7i8ch0pwtk82rStKVdGzatGX9zp13t3V3Hyy1tb0qhBAAYoxj44ODm970P//ncLNrXC4MWWbBkEWSJEmSJEmam0qWtQEZqWfLHtJ9tjPA2r7pKC1zHRs3XtOdApe3xsnJS2ePHj1oT5YphiyzYMgiSZIkSZIkzU8lyzqBm0lhy7XAeeBcM2uSdFW2EkKVGP+bIcuU2eQGrUtTkiRJkiRJkqTVqpznI8AXKln2LHAr8GrgAKlXS28TS5P0StZ6T4x5MmSRJEmSJEmStCDKeT4AfKaSZU8DryqWa4GTwEAza5OkxWDIIkmSJEmSJGlBlfO8FzhcybKnSL1abgF2ACcAJ9eWtGqUml2AJEmSJEmSpNWpnOcvAR8HPgI8AewErgfam1eVJC0ce7JIkiRJkiRJWjTlPI/AiUqWnSIFLXcCNwBjpGHEJppYniTNiyGLJEmSJEmSpEVXzvMq8Fwly44BN5LClhuBfuAMUG1ieZI0J4YskiRJkiRJkpZMOc8ngKcqWfYCsJ8UtuwHLgDngNjE8iRpVgxZJEmSJEmSJC25cp6PAl+sZNmzwAHgruLxLClwkaRlz5BFkiRJkiRJUtOU83wIeKiSZTlwG3AHcDNwijSUmCQtW4YskiRJkiRJkpqunOd9wAOVLHsauJ0UuGwHTgJDzaxNkmZiyCJJkiRJkiRp2Sjn+XngE5UsexJ4NWkIsRJwAhhtZm2SNF2p2QVIkiRJkiRJ0nTlPD8NfAz4M+BZYA9wHX5wXNIy4gVJkiRJkiRJ0rJUzvMIvFjJshPADcCdxeMQac6WahPLkyRDFkmSJEmSJEnLWznPJ4FnKln2AnATcBewH+gFzgKxacVJWtMMWSRJkiRJkiStCOU8Hwcer2TZc6S5Wu4sHl8CzjezNklrkyGLJEmSJEmSpBWlnOcjwMOVLMuB24BXAzeTerX0NrE0SWuMIYskSZIkSZKkFamc5wPAg5Usexq4nRS4XAucAAabWZuktcGQRZIkSZIkSdKKVs7zi8DfVbLsSeAO4BZgBylsGWlmbZJWt1KzC5AkSZIkSZKkhVDO87PAx4E/A54GdgHXA+1NLEvSKmZPFkmSJEmSJEmrRjnPI3C8kmUnSQHLncXjKHASmGxacZJWHUMWSZIkSZIkSatOOc+rwLOVLHsRyIC7isd+4AxQbV51klYLQxZJkiRJkiRJq1Y5zyeAJytZ9jxwMyls2Q+cB841rzJJq4EhiyRJkiRJkqRVr5zno8AjlSx7FjhAGkbsAHAWuNjM2iStXIYskiRJkiRJktaMcp4PAp+vZFkOvAq4ndTD5RRpKDFJumqGLJIkSZIkSZLWnHKeXwKOVLLsKVLQchuwHTgBDDezNkkrhyGLJEmSJEmSpDWrnOfngPuLsOUOUq+WEnAcGGtmbZKWv1KzC5AkSZIkSZKkZivn+UngY8CfA88Ce4F9+EF1SVfgBUKSJEmSJEmSgHKeV4EXKll2HLgRuAu4ARgETgPV5lUnaTkyZJEkSZIkSZKkOuU8nwSermTZC8BNpLBlP9ALnAVi04qTtKwYskiSJEmSJElSA+U8HwMeq2TZc8AB4E7SnC0vAReaWZuk5cGQRZIkSZIkSZKuoJznw8DRSpblwK3Aq0mhy2ngUjNrk9RchiySJEmSJEmSdBXKed4PPFjJsmeA24HbgO3ACdK8LZLWGEMWSZIkSZIkSZqFcp5fAP62kmVPknq17Ad2k4YQuwBUm1iepCVUanYBkiRJkiRJkrQSlfP8DPDXwJ8AnypW3wTsAdqbVZekpWNPFkmSJEmSJEmao3KeR+AMcKaSZQ8D15PmbdlD+pD7WaCvaQVKWlSGLJIkSZIkSZK0AMp5Pgg8WsmyJ0jDh90M3AjsBHqBc8Bk0wqUtOAMWSRJkiRJkiRpAZXzfBJ4EXixkmWbSb1bbiMFLuOkni/DTStQ0oIxZJEkSZIkSZKkRVLO8wvAhUqWPQpcBxwA9gGdpJ4tF4HYvAolzYchiyRJkiRJkiQtsnKejwJPVbLsGWA7cBNpOLGbgQHS3C3jzatQ0lwYskiSJEmSJEnSEinneRU4BZyqZNlR0lBitwJ7gUAKW/qbVZ+k2TFkkSRJkiRJkqQmKOd5P/BIJcseJ4Us+0nztuwiDSN2Dqg2r0JJr8SQRZIkSZIkSZKaqJznE8BzwHOVLNtKClpuIQ0pNkLq3TLSvAolzcSQRZIkSZIkSZKWiXKenwPOVbLsEeA60lBie4A24CWgt3nVSZrOkEWSJEmSJEmSlplyng8DT1Sy7ClgJ6lXy37gANBHClwmmlehJDBkkSRJkiRJkqRlq5znVeAEcKKSZUeB64HbiscqcAYYbFJ50ppnyCJJkiRJkiRJK0A5zy8BD1ey7DFgH6lXy3XAbuBCsVSbV6G09hiySJIkSZIkSdIKUs7zcSCvZNmzwDbgRtLcLTcBw6TeLWPNq1BaOwxZJEmSJEmSJGkFKud5BM4CZytZ9gipV8utwB6gRJq35VLzKpRWP0MWSZIkSZIkSVrhynk+CDxWybInScOH3VQsO0hBy0vAZPMqlFYnQxZJkiRJkiRJWiXKeT4JvAi8WMmyh4AbSL1bbgAmSD1fhppXobS6GLJIkiRJkiRJ0ipUzvOLwMVKlj0K7ANuKR47gXPARSA2r0Jp5TNkkSRJkiRJkqRVrJzno8DTlSx7BtgOZMABYD8wSBpKbKx5FUorlyGLJEmSJEmSJK0B5TyPwGngdCXLHgauJw0ltqfY5SWgvznVSSuTIYskSZIkSZIkrTHlPB8AvljJsidIIcvNpHlbdgG9pMCl2rQCpRXCkEWSJEmSJEmS1qhynk8AzwPPV7JsCylouY00pNgYcBYYblqB0jJnyCJJkiRJkiRJopzn54HzlSz7InAdcAuwj3Qf+TxwsYnlScuSIYskSZIkSZIk6UvKeT4CPFnJsqeBnaReLTcDB4A+0lBiE82rUFo+DFkkSZIkSZIkSS9TzvMqcAI4Ucmyo6ShxG4l9XKJpKHEBppWoLQMGLJIkiRJkiRJkq6onOd9wMOVLHsM2Evq2XI9sJs0lNgFoNq0AqUmMWSRJEmSJEmSJF2Vcp6PA89Wsuw5YBtTvVtuAkaAM8Bo8yqUlpYhiyRJkiRJkiRpVsp5Xhsu7Gwlyx4hDSF2K7AHaAHOAb1NK1BaIoYskiRJkiRJkqQ5K+f5EPB4JcueAnaRerXcBBwALpECl4nmVSgtHkMWSZIkSZIkSdK8lfN8EjgGHKtk2UOkocRuI83dMknq+TLYtAKlRWDIIkmSJEmSJElaUOU87wUeqmTZo8A+4BbSkGK7gfPABSA2rUBpgRiySJIkSZIkSZIWRTnPx4BnKlmWA9uBG0nDiN1M6tVyFhhrXoXS/BiySJIkSZIkSZIWVTnPI3AaOF3Jsi+QhhC7FdgDBOAloK9pBUpzZMgiSZIkSZIkSVoy5TwfAL5YybInSMOH3Uyav2Un0AucI83hIi17hiySJEmSJEmSpCVXzvMJ4AXghUqWbSH1brmNNKTYOHAGGG5agdJVMGSRJEmSJEmSJDVVOc/PA+crWfYocB1p3pZ9QDtwHrgIxOZVKDVmyCJJkiRJkiRJWhbKeT4CPFnJsqeBHUBGGk7sZqCfNHfLePMqlC5nyCJJkiRJkiRJWlbKeV4FTgInK1n2MFNDie0j9Wg5Cww0rUCpUGp2AY2EEH4ghPB8CGEkhPDpEMKXXWHfrw8hfDaE0BtCGAwhHA0hfPtS1itJkiRJkiRJWhzlPO8r5/kXgD8B/gx4AthI6t2yjWV6n1trw7LryRJC+GbgV4HvAz4NvBv4aAjhQIzxbINDLgD/nvSDNQb8Y+D9IYSzMcaPLk3VkiRJkiRJkqTFVM7zceC5SpY9D2wFbgBuIQ0pNgqcKR6lJRNiXF5zBYUQPg18Jsb4ruLrEnAM+M0Y4y9e5XN8HvjLGONPX8W+G4BLwMYYY9/cK5ckSZIkSZIkLaVKlnWRhhK7BdhD6lhwDuhtXlUrylZgEvhgMUSbmF1usKx6soQQ2oHXAb9QWxdjrIYQ/hq4+yqOD8DbgAPAj82wTwfQUbeqZz41S5IkSZIkSZKao5znw8DjlSx7EtgF3FQsB4A+4CVgonkVarVbViELKTVrIXXrqneGlEQ2FELYCJwghSeTwPfHGD82w+4/Abxn/qVKkiRJkiRJkpaDohfGceB4JcuOknq33FY8TgJngcEmladVbLmFLHPVD9wFrAe+AvjVEMKzMcb7G+z7C6Q5X2p6SD98kiRJkiRJkqQVrpznvcDRSpY9BuwDbiaFLbtJc3yfB5bXPBpasZZbyHKOlCpun7Z+O3B6poNijFXgmeLLoyGEW0k9Vu5vsO8odZMfpRHGJEmSJEmSJEmrSTnPx4BnKlmWA9cCGWkYsf3AEKl3y1jzKtRqsKxClhjjWAjhc6TeKB+BL018/xXA+2bxVCUun3dFkiRJkiRJkrQGlfM8kqakOFPJsodJvVpuBfaQ7iWfJc3fIs3asgpZCr8K/H4I4bPAg8C7gW7g/QAhhA8AJ2KMP1F8/RPAZ4GcFKx8FfDtwDuXvHJJkiRJkiRJ0rJVzvNB4NFKlj1BGj5sP6mHy06gl6nRlqSrsuxClhjjH4YQtgH/FtgBHAX+7xjjmWKXfUC17pBu4LdIqeMw8ATwbTHGP1yyoiVJkiRJkiRJK0Y5zyeBF4EXK1n2EKl3y23ADcAEqefLcNMK1IoRYlzb8/uEEDYAl4CNMUa7hEmSJEmSJEnSGlTJsg7gOtK8LfuATlLPlovAar2RvpXUc+eD5TyvvtLOa8VscoNl15NFkiRJkiRJkqSlVs7zUeCpSpY9A2wHbgJuLpYB0twt482rUMuRIYskSZIkSZIkSYWiR8cp4FQly46ShhK7FdgLBFLY0t+s+rS8GLJIkiRJkiRJktRAOc/7gUcqWfY4KWTZD9wI7CINI3aOy+cQ1xpjyCJJkiRJkiRJ0hWU83wCeA54rpJlW0lByy2kIcVGSL1bRppXoZrFkEWSJEmSJEmSpKtUzvNzwLlKlj0CXEcaSmwP0Aa8BPQ2rzotNUMWSZIkSZIkSZJmqZznw8ATlSx7CthJ6tWyHzgA9JECl4nmVailYMgiSZIkSZIkSdIclfO8CpwATlSy7ChwPXBb8ThJGkpssEnlaZEZskiSJEmSJEmStADKeX4JeLiSZY8B+0i9Wq4DdgMXiqXavAq10AxZJEmSJEmSJElaQOU8HwfySpY9C2wDbiTN3XITMAycAcaaV6EWiiGLJEmSJEmSJEmLoJznkTRc2NlKlj1C6tVyK6lnSwtp3pZLzatQ82XIIkmSJEmSJEnSIivn+SDwWCXLniSFLDcVyw5S0PISaQ4XrSCGLJIkSZIkSZIkLZFynk8CLwIvVrLsIeAGUu+WG4AJUs+XoeZVqNkwZJEkSZIkSZIkqQnKeX4RuFjJskeBfcAtxWMncA64CMTmVahXYsgiSZIkSZIkSVITlfN8FHi6kmXPANuBDDgA7AcGSUOJjTWvQs3EkEWSJEmSJEmSpGWgnOcROA2crmTZw8D1pKHE9hS7vAT0N6c6NWLIIkmSJEmSJEnSMlPO8wHgi5Use4IUstxMmrdlF2kYsXNAtXkVCgxZJEmSJEmSJElatsp5PgE8DzxfybItpKDlNtKQYmPAWWC4aQWucYYskiRJkiRJkiStAOU8Pw+cr2TZF4HrgFuAfaR7/edJPVy0hAxZJEmSJEmSJElaQcp5PgI8Wcmyp4GdpF4tNwMHgD7S3C0Tzatw7TBkkSRJkiRJkiRpBSrneRU4AZyoZNlR0lBit5J6uUTSUGIDTStwDTBkkSRJkiRJkiRphSvneR/wcCXLHgP2knq2XA/sJg0ldgGoNq3AVcqQRZIkSZIkSZKkVaKc5+PAs5Usew7YxlTvlpuAEeAMMNq8ClcXQxZJkiRJkiRJklaZcp7Xhgs7W8myR0hDiN0K7AFagHNNLG/VMGSRJEmSJEmSJGkVK+f5EPB4JcueAnYBGbCf1NPleDNrW+kMWSRJkiRJkiRJWgPKeT4JHAOOVbLsKGkosfVAbGZdK1mIcW2/dyGEDcAlYGOMsa/Z9UiSJEmSJEmSpOaZTW5QWpqSJEmSJEmSJEmSVhdDFkmSJEmSJEmSpDkwZJEkSZIkSZIkSZoDQxZJkiRJkiRJkqQ5MGSRJEmSJEmSJEmaA0MWSZIkSZIkSZKkOTBkkSRJkiRJkiRJmgNDFkmSJEmSJEmSpDkwZJEkSZIkSZIkSZoDQxZJkiRJkiRJkqQ5MGSRJEmSJEmSJEmaA0MWSZIkSZIkSZKkOTBkkSRJkiRJkiRJmgNDFkmSJEmSJEmSpDkwZJEkSZIkSZIkSZoDQxZJkiRJkiRJkqQ5MGSRJEmSJEmSJEmaA0MWSZIkSZIkSZKkOTBkkSRJkiRJkiRJmgNDFkmSJEmSJEmSpDkwZJEkSZIkSZIkSZoDQxZJkiRJkiRJkqQ5MGSRJEmSJEmSJEmaA0MWSZIkSZIkSZKkOTBkkSRJkiRJkiRJmoPWZhewjPSEEJpdgyRJkiRJkiRJaq6eq93RkGXqzTre1CokSZIkSZIkSdJy0gP0XWmHEGNcolqWp5C6r+wC+ptdyzLUQwqf9uD7o5XH9quVzParlcz2q5XM9quVzParlc42rJXM9quVzPY7sx7gZHyFEGXN92Qp3qATza5jOaobPq0/xnjFtE5abmy/Wslsv1rJbL9ayWy/Wslsv1rpbMNayWy/Wslsv1d0Ve+HE99LkiRJkiRJkiTNgSGLJEmSJEmSJEnSHBiy6EpGgZ8rHqWVxvarlcz2q5XM9quVzParlcz2q5XONqyVzParlcz2O09rfuJ7SZIkSZIkSZKkubAniyRJkiRJkiRJ0hwYskiSJEmSJEmSJM2BIYskSZIkSZIkSdIcGLJIkiRJkiRJkiTNgSHLKhZC6Agh/IcQwskQwnAI4dMhhH9wlcfuDiF8OITQG0LoCyH8WQjhxhn2/a4QwuMhhJEQwtMhhB9c2FeitWop2nAIIc6w/PjCvyKtJXNtvyGEAyGEXwshHCmuqzGEcP0V9v/qEMLni31fDCH8XAihdUFfjNacpWi/IYTnZ7j+/vaCvyCtKfNov18fQvjDEMKzIYShEMKTIYRfCSFsmmF/r79acEvRfr3+arHMo/1+XQjho8VxoyGE4yGEPw4h3D7D/l5/teCWov16/dVimmsbbvA8Hyva5ftm2O594Ab8T2h1uxd4O/DrwNPAO4D/FUK4J8b4yZkOCiGsB+4DNgLvBcaBfwV8IoRwV4zxfN2+3wv8NvAnwK8CbwF+I4SwLsb4HxbhNWltuZdFbsOFjwEfmLbuoQWoX2vbvcyh/QJ3A/8SeAx4HLhrph1DCP8Q+AhwP/CDwB3AvwGuBd45r+q11t3LIrffwlHgV6ate2q2xUrT3Mvc2u9/AU4CHwReJF1T3wV8VQjhtTHG4dqOXn+1iO5lkdtv4Shef7Xw7mVu7fcO4CLwn4BzwA7gnwMPhhDujjE+XNvR668W0b0scvstHMXrrxbHvcytDX9JCOHrSX/TzbTd+8AziTG6rMIF+DIgAj9St64TeAY48grH/uvi2DfUrbsFmADeW7eui/QfyF9MO/6DwABwTbPfB5eVuyxFGy7WR+B9zX69LqtrmWf73Qz0FP/+keJ5rp9h30dJv6S31q37eaAK3NLs98FlZS5L2H6fn/47hIvLfJd5tt+3Nlj3HcXz/Ytp673+uiz4soTt1+uvy4Iv82m/MzzfdtKH5X572nqvvy4Lvixh+/X667Ioy0K04WL/54CfpsG9MrwPfMXF4cJWr7cDk6RPNAEQYxwB/itwdwhh7ysc+5kY42fqjn0C+Bvgm+r2uwfYAvzWtOP/M9AN/KP5vACteUvRhr8khNAVQuhciMIl5tF+Y4wXYoz9r3SCEMJtwG3Af4kxTtRt+i0gFDVIc7Ho7bdeCKE9hNA912KlaebTfu9vsPp/Fo+31lZ4/dUiWvT2W8/rrxbYfP5+a+QsMARsqq3w+qtFtOjtt57XXy2ChWjD/5o0tcgvz7Dd+8BXYMiyer0GeCrG2Ddt/YPF412NDgohlIBXA59tsPlBIAsh9NSdgwb7fo70KZLXIM3dUrThmncAg8BwCOGxEMK3zLVoqTCn9juHc8C0th5jPAkcx2uw5m4p2m/N20h/gA4UY1T/0AI+t9amhW6/O4rHc9POAV5/tfCWov3WeP3VQpt3+w0hbAohbAsh3AH8LrCB9EG5+nOA118tvKVovzVef7UY5tWGQwj7gB8Hfiy+fIjR+nOA94Ebck6W1WsncKrB+tq6XTMctxnouIpjnyzOMRljPFu/U4xxLIRw/grnkK7GUrRhgCPAh0ldIncBPwD89xDCxhjj/zuHuiWYe/ud7Tnqn3P6ebwGa66Wov0CfAH4JOl6vIUUeP96CGFXjPHHFugcWnsWuv3+GOlTgX887Rz1zzn9PF5/NVdL0X7B668Wx0K03weAA8W/B0jDgP3Xaeeof87p5/H6q7laivYLXn+1eObbhn8FeCjG+KFXOIf3gWdgyLJ6dQGjDdaP1G2f6Tiu8tguYGyG5xm5wjmkq7EUbZgY46H6HUIIv0dK4d8bQrj3Cgm+dCVzbb+zPQdXOM+GBTiH1qalaL/EGL+6/usQwvuBvwJ+OITwmzHG4wtxHq05C9Z+i56t3wX8Uozx6Wnn4Arn8fqruVqK9uv1V4tlIdrvPyNdQ28s/t0FtJA+IV3/HF5/tdCWov16/dVimnMbDiHcA3wD8MarOIf3gWfgcGGr1zDp0/zTddZtn+k4rvLYYaB9hufpvMI5pKuxFG34ZWKMY8D7SGOnvu4Vq5Qam2v7ne05uMJ5vAZrrpai/b5MTLMm/hrpQ0BvXYxzaE1YkPYbQngL6dOnHwV+qsE5uMJ5vP5qrpai/b6M118tkHm33xjjp2KMHy1GFPhK4NuAX5h2Dq5wHq+/mqulaL+NjvH6q4UypzYcQmgFfgP4b/XzGl/hHN4HnoEhy+p1iqmutPVq607OcNwFUvJ5NceeAlpCCNfW7xRCaCd1e5zpHNLVWIo2PJNjxePmV9hPmslc2+9sz1H/nNPP4zVYc7UU7XcmXn81X/NuvyGEO4E/B74IvH3a5Mq1c9Q/5/TzeP3VXC1F+52J11/N14L+/hBjvAh8HPjWaeeof87p5/H6q7laivY7E6+/WghzbcPfQRrm7ndCCNfXlmJbT/H1urpzeB94BoYsq9dR4OYQwvTusm+s2/4yMcYq8Ajw+gab3wg8G2Psn/Yc0/d9PaltNTyHdJWOsvhteCY3Fo8vXVWl0ssdZQ7tdw7ngGltPYSwC9izQOfQ2nSUxW+/M/H6q/k6yjzabwghA/43cBb4qhjjwAznAK+/WnhHWfz2OxOvv5qvoyz87w9dwMZp5wCvv1p4R1n89jsTr79aCEeZWxveB7QBh0lzFdcWSAHMc8D/Ne05vA/cgCHL6vXHpLEfv6e2IoTQQRoX8tMxxmPFun0hhFsaHPuGEMLr6449ALwN+KO6/T5O6jXwzmnHvxMYAv5yYV6K1qhFb8MhhG3TTxpC6AHeDZwjzc0izcV82u9ViTE+CjwBfE8IoaVu0zuByMsnuZWu1qK33xDC5mntlhBCG/DjpHF+75tj7dKc228IYQfwf0hjp39ljLHhzQ6vv1pEi95+vf5qEc2n/V72qehi3fXAVwCfra3z+qtFtOjt1+uvFtlc2/CHgK9rsAD8r+Lfny6+9j7wFTjx/SoVY/x0COGPgF8oLvjPAN8JXE+aALHmA8CXA6Fu3W8B3w38ZQjhl4Fx4IeBM8Cv1J1jOITw08B/Ls71UeAtpHEnfyrGeGGRXp7WgKVow8APhBC+FqgAL5K6Uf5zUpL/7cX8LNKszaf9hhA2Aj9YfHmoeHxXCKEX6I0xvq/u+B8lDQnyf0IIHwJuB94F/G6M8fGFfl1aG5ao/X418G9CCH9M+nTUZuBbSG34J2OMpxfhpWkNmOfvD/+b9GnSXwLeHEJ4c922MzHGj9V97fVXC26J2q/XXy2KebbfR0IIf0P6FPRFYH9xTO0GdD2vv1pwS9R+vf5q0cy1DccYnyCF15cJIQA8F2P8SN05vA98JTFGl1W6kCYd+o+kMfNGgAdJn2qq3+d+irm2pq3fQ/rE/yWgn3QT+qYZzvPdpB/IUdIP8buB0OzX77Lyl8Vuw8A/IH3i7xTpkyMXSf9JvK3Zr91l5S9zbb+kX4LiDMvzDc7ztcBDxTmOAf8OaGv263dZ2ctit1/gdaQbJMeL3x/6gb8DvrHZr91l5S/zaL8ztd0I3N/gPF5/XRZ8Wez26/XXZTGXebTfnwU+Q/qE9DhwAvgD4I4ZzuP112XBl8Vuv15/XRZ7mWsbnuG5IvC+GbZ5H7jBEoo3R5IkSZIkSZIkSbPgnCySJEmSJEmSJElzYMgiSZIkSZIkSZI0B4YskiRJkiRJkiRJc2DIIkmSJEmSJEmSNAeGLJIkSZIkSZIkSXNgyCJJkiRJkiRJkjQHhiySJEmSJEmSJElzYMgiSZIkSZIkSZI0B4YskiRJkiRJkiRJc2DIIkmSJElaUCGE60MIMYTwjmbXIkmSJC0mQxZJkiRpBQshvKO4mV1bRkIIT4UQ3hdC2N7s+uYrhHBbCOFnQwjXN7uWVxJCuHfa92K0+F782xBCZ7PrkyRJkrTwWptdgCRJkqQF8TPAc0An8GbgncBXhRBujzEONbWy+bkNeA9wP/B8Uyu5OqPAvyj+vRH4GuCngQz41mYVJUmSJGlxGLJIkiRJq8NfxRg/W/z7d0MI54EfJt3k/4P5PHEIYd0KD2qW0kSM8YO1L0IIvwUcAf5pCOGHY4xnmleaJEmSpIXmcGGSJEnS6vTx4vGG2ooQwreFED4XQhgOIVwIIXwohLC3/qAQwv0hhC+GEF4XQvjbEMIQ8N5iW2cxdNdTxbBkp0IIfxpCyOqOL4UQ3h1CeLTY50wI4XdCCNdMO8/zIYS/CCG8OYTwYLHvsyGE76jb5x3AHxVf3lc3DNdbi+1fE0L4yxDCyWJorjyE8NMhhJbpb0YI4QeK5x8uzveW4rXeP22/jhDCz4UQnime81gI4ZdCCB2z/QYAxBgj8EkgADdOO9c/DCH8XQhhMITQX7yWV03b594QwkAIYV/xfg2EEE6EEH6g2H5HCOHjxXO8EEL4lgav/cYQwh8V3/OhEMIDIYR/VLd9ewhhIoTwngbHHije83cVX28OIfxyCOGRopa+EMJfhRDunMv7I0mSJK10hiySJEnS6lQLPs4DhBB+CvgA8DSph8uvA18B/G0IYdO0Y7cAfwUcBd5NCjhagL8gDd31OeD/Af4TaUis2+uO/R3gPwKHgR8C3k8aJuujIYS2aee5Cfhj4GPF810E7q0LGv4W+I3i3+8Fvr1YHi/WvQMYAH61ONfngH8L/GL9SUII7wTeBxwH/jXwd8BHgD3T9isBfw78CFABfrDY718Bf8jcXV88Xqw717cDf1nU/2PAvyMNjfbJBvPPtJC+H8eK+p8H3leEUP8b+GzxHP3AB0II9cHadlJPmq8Efgv4KdKQcn8eQvg6gKJ3zSeAb2pQ+zcDk0yFXTcCX0tqCz9M+l7fAXwihLDrKt8PSZIkadUI6YNVkiRJklai4kb7+4G/DzxMuoF+CPjPwDpgP2mY4Bz4mRjje+uOvR14CHhPbX3Rs+PLge+LMf5O3b7/DPg94IdjjL82rYYQY4whhDeTAoxvjTH+j7rtX0kKA760PoTwPHAd8PdijH9XrNtGChLeF2P8kWLd20k3+O+JMd4/7bxdMcbhaet+mxTEbI4xjoYQ2oGTwLPAwRjjRLHfdwL3Ap+IMb61WPdtwO8DXx5j/GTdc34v8NvAoRjjkUbfh2K/e4G3MxWqbCQFEv8ReBR4dfE+rS9e5x/FGL+n7vjtwJPAh2vri+f8TuAnY4y/UKzbVLymTuCfxhj/sFh/AHgC+LkY488W636NFJS9pfaaivN/gdS7JosxVkMI30MKyO6IMX6xrqZHgdMxxq8ovu4AxmOM1bp9ri/O++9jjP+ubt1zwD+LMd4703smSZIkrXT2ZJEkSZJWh78GXiLdvP8QqYfE18UYTwBfT/rd/8MhhK21BThN6tlyz7TnGiUFN/W+ATgH/Ob0E8epT259I3AJ+Ni083yuqGf6eR6rBSzF87xEChlu5CrUBywhhJ7iXH9HCpduKTa9ntQz5/+rBSyF/05dz5K6+h8HnphWf23oten1N9JN+j68BDwD/DKpV8/X1L1P/wDYBPzBtPNMAp+e4Ty/W/e6e0nv0yDw4br1TwK9XP7+fRXwYH1oFGMcAP4LKQy6rVj9p8AEqecK8KUQ7jbqevHEGEdrAUsIoSWEsIX0vX0SeO0rvDeSJEnSquPE95IkSdLq8APAU6Qb5WeAJ+t6G+wn9Vp4eoZjx6d9fSLGODZtXVY85wQz20/qvXF2hu3XTvv6xQb7XASuabD+ZYphxX4eeBuwYdrmjcXjdcXjM/UbY4wTRW+aevuBW0kBSSPT629kBCgX/95DGt7rWqC+x83+4vHjNNY3/TmLAKreJeB4XXBTv77+/buOFNxM93jd9i/GGM+FEP6GNGTYTxfbvpnUnv60dlAxpNoPAd9Pmu+nfv6b8zO8HkmSJGnVMmSRJEmSVocHY4yfnWFbCYjAPyT1lphuYNrXww32uRolUsDyrTNsnx4UNKoFUiB0RcWQWZ8gBRI/QxoObYTUm+I/MLde+yXgEdJcI40cu4rnmIwx/nVdnR8lDaX1O8BX150H0rBmpxs8x/Qga6b3ac7v3ww+BLw/hHBXjPEoKXD5mxjjubp9fpI0f8zvkcKYC0CVNMePIyVIkiRpzTFkkSRJkla/nHTj/bkY41PzeI43hhDaYozTe77U7/P3gcPT50qZh5kmkXwraRiwr48x/m1tZf2k74UXisebgPvq9mslDZf1hbp9c+BOUrCwIJNXxhhPFfOivCeE8KYY4wPFeQDO1gcyi+QF4ECD9bfUba/5CCkM+uYQAsDNwC9MO+7twH0xxu+qX1mEXueQJEmS1hg/aSRJkiStfn9K6vXwnlDcPa8JyZareI4/AbYC75q+oe45P0waPuqnG+zTWtyIn63B4nH6sbVeHF96PcUk998/bb/Pkoax+u4iWKn5Vl4+LNmHgd3Ad08vIoTQFULonlXlU34TGAJ+vPj6o6QeOD8ZQmhrcK5tczxPI/8L+LIQwt11z98NfA/wPPBYbX0x18tHST1Y/gkwRgpe6k0yradMCOEbSe+bJEmStObYk0WSJEla5WKMeQjh35B6JVwfQvgI0E+aU+PrSJOg//IrPM0HgO8AfjWE8GWkCea7ST1Xfgv4sxjjJ0IIvwP8RAjhLuD/kOZ72U+aVP6HgD+eZflHSTf2fyyEsBEYJc1lcoQ0f8vvhxB+g9Tj5duZFgDEGMdCCD9LCjo+HkL4MKkHyztIPUrqe6z8N1LA8NshhHtIE9a3kHp9fBPwlaTQZlZijOdDCO8Hvj+EcGuM8fEQwjuL830+hPAh0lBq+4B/VJz3ZWHWHP0i8E+BvyrepwvAd5K+999QN29PzR8CHySFVR8tgpd6fwH8TPF6jgB3kAKrZxeoXkmSJGlFMWSRJEmS1oAY4y+GEJ4C/hXwnmL1MVIQ8udXcfxkCOGrgJ8CvgX4BlIPkU+S5jGp7fd9IYTPAd8LvJc0v8jzpBv3h+dQ9+kQwvcBPwH8V1LocU+M8f4Qwj8GfgX4eVLg8kHgb0i9Meqf431Fb5v/hxQmPUyaH+U3SPO41ParhhC+lvQefQcpgBoiBQj/CZjrUGsAvwp8H/BjwDtijP8jhHCS1LvlR4EO4AQpvHr/PM5zmRjjmRDCQdI8NT8IdJKGSCvHGP+ywSF/TpqTp4cUuEz3XlK49i3ANwOfJwVDv7hQNUuSJEkrSVigoYYlSZIkacUIIZRIvUf+NMb4suHBJEmSJOlqOCeLJEmSpFUthNA5fS4aUk+VzcD9S1+RJEmSpNXCniySJEmSVrUQwluBXwP+iDTE2WuB7wIeB14XYxxrWnGSJEmSVjTnZJEkSZK02j1Pmn/mX5J6r1wAPgD8uAGLJEmSpPmwJ4skSZIkSZIkSdIcOCeLJEmSJEmSJEnSHBiySJIkSZIkSZIkzYEhiyRJkiRJkiRJ0hwYskiSJEmSJEmSJM2BIYskSZIkSZIkSdIcGLJIkiRJkiRJkiTNgSGLJEmSJEmSJEnSHBiySJIkSZIkSZIkzcH/D5kicIbWAaqZAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -669,7 +669,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "241aded4b743402b962d09d78df0705f", + "model_id": "fcd1e0c6103a4b2aa4358a2b82218c66", "version_major": 2, "version_minor": 0 }, @@ -723,7 +723,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 1f7d7f2d6cbb4c672d9c0a3062b71d399e1a965d Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 12 Apr 2024 16:10:00 +0200 Subject: [PATCH 38/42] Rename rank stability and homogeneize interface --- docs/value/semi-values.md | 7 ++++--- notebooks/msr_banzhaf_digits.ipynb | 4 ++-- src/pydvl/value/semivalues.py | 4 ++-- src/pydvl/value/stopping.py | 24 ++++++++++++++++-------- tests/value/test_stopping.py | 12 ++++++------ 5 files changed, 30 insertions(+), 21 deletions(-) diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index 2dabc0dfb..515418601 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -115,13 +115,14 @@ $\mathbf{S}_{\not{\ni} i}$ are the subsets not containing the index $i$. The function implementing this method is [compute_msr_banzhaf_semivalues][pydvl.value.semivalues.compute_msr_banzhaf_semivalues]. + ```python -from pydvl.value import compute_msr_banzhaf_semivalues, RankStability, Utility +from pydvl.value import compute_msr_banzhaf_semivalues, RankCorrelation, Utility utility = Utility(model, data) values = compute_msr_banzhaf_semivalues( - u=utility, done=RankStability(rtol=0.001), -) + u=utility, done=RankCorrelation(rtol=0.001), + ) ``` For further details on how to use this method and a comparison of the sample efficiency, we suggest to take a look at the example notebook diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb index 8dff51298..1a6239f3c 100644 --- a/notebooks/msr_banzhaf_digits.ipynb +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -694,7 +694,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Computing the values is the same, but we now use a better stopping criterion. Instead of fixing the number of utility evaluations with [MaxChecks](../../api/pydvl/value/stopping/#pydvl.value.stopping.MaxChecks), we use [RankStability](../../api/pydvl/value/stopping/#pydvl.value.stopping.RankStability) to stop when the change in Spearman correlation between the ranking of two successive iterations is below a threshold. " + "Computing the values is the same, but we now use a better stopping criterion. Instead of fixing the number of utility evaluations with [MaxChecks](../../api/pydvl/value/stopping/#pydvl.value.stopping.MaxChecks), we use [RankCorrelation](../../api/pydvl/value/stopping/#pydvl.value.stopping.RankCorrelation) to stop when the change in Spearman correlation between the ranking of two successive iterations is below a threshold. " ] }, { @@ -715,7 +715,7 @@ "source": [ "values = compute_msr_banzhaf_semivalues(\n", " utility,\n", - " done=RankStability(0.0001),\n", + " done=RankCorrelation(rtol=0.0001, burn_in=10),\n", " n_jobs=n_jobs,\n", " progress=True,\n", ")\n", diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 6de2e10ba..e7bc53c7b 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -117,7 +117,7 @@ SampleT, StochasticSampler, ) -from pydvl.value.stopping import MaxUpdates, RankStability, StoppingCriterion +from pydvl.value.stopping import MaxUpdates, RankCorrelation, StoppingCriterion __all__ = [ "compute_banzhaf_semivalues", @@ -635,7 +635,7 @@ def compute_banzhaf_semivalues( def compute_msr_banzhaf_semivalues( u: Utility, *, - done: StoppingCriterion = RankStability(0.01), + done: StoppingCriterion = RankCorrelation(0.01), sampler_t: Type[StochasticSampler] = MSRSampler, batch_size: int = 1, n_jobs: int = 1, diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index b3d1fdb13..e3947788e 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -143,7 +143,7 @@ "MinUpdates", "MaxTime", "HistoryDeviation", - "RankStability", + "RankCorrelation", ] logger = logging.getLogger(__name__) @@ -630,7 +630,7 @@ def __str__(self): return f"HistoryDeviation(n_steps={self.n_steps}, rtol={self.rtol})" -class RankStability(StoppingCriterion): +class RankCorrelation(StoppingCriterion): r"""A check for stability of Spearman correlation between checks. When the change in rank correlation between two successive iterations is @@ -645,23 +645,31 @@ class RankStability(StoppingCriterion): Args: rtol: Relative tolerance for convergence ($\epsilon$ in the formula) + modify_result: If `True`, the status of the input + [ValuationResult][pydvl.value.result.ValuationResult] is modified in + place after the call. + burn_in: The minimum number of iterations before checking for + convergence. This is required because the first correlation is + meaningless. + + !!! tip "Added in 0.9.0" """ def __init__( self, rtol: float, + burn_in: int, modify_result: bool = True, - min_iterations: int = 10, ): super().__init__(modify_result=modify_result) if rtol <= 0 or rtol >= 1: raise ValueError("rtol must be in (0, 1)") self.rtol = rtol - self._memory = None # type: ignore + self.burn_in = burn_in + self._memory: NDArray[np.float_] | None = None self._corr = 0.0 self._completion = 0.0 self._iterations = 0 - self.min_iterations = min_iterations def _check(self, r: ValuationResult) -> Status: self._iterations += 1 @@ -675,11 +683,11 @@ def _check(self, r: ValuationResult) -> Status: self._update_completion(corr) if ( np.isclose(corr, self._corr, rtol=self.rtol) - and self._iterations > self.min_iterations + and self._iterations > self.burn_in ): self._converged = np.full(len(r), True) logger.debug( - f"RankStability has converged with {corr=} in iteration {self._iterations}" + f"RankCorrelation has converged with {corr=} in iteration {self._iterations}" ) return Status.Converged self._corr = np.nan_to_num(corr, nan=0.0) @@ -702,4 +710,4 @@ def reset(self): self._corr = 0.0 def __str__(self): - return f"RankStability(rtol={self.rtol})" + return f"RankCorrelation(rtol={self.rtol})" diff --git a/tests/value/test_stopping.py b/tests/value/test_stopping.py index f5851c6cf..44eee75f9 100644 --- a/tests/value/test_stopping.py +++ b/tests/value/test_stopping.py @@ -13,7 +13,7 @@ MaxTime, MaxUpdates, MinUpdates, - RankStability, + RankCorrelation, StoppingCriterion, make_criterion, ) @@ -199,12 +199,12 @@ def test_max_checks(): assert done(v) -def test_rank_stability(): - """Test the RankStability stopping criterion.""" +def test_rank_correlation(): + """Test the RankCorrelation stopping criterion.""" v = ValuationResult.zeros(indices=range(5)) arr = np.arange(5) - done = RankStability(rtol=0.1) + done = RankCorrelation(rtol=0.1) for i in range(20): arr = np.roll(arr, 1) for j in range(5): @@ -213,14 +213,14 @@ def test_rank_stability(): assert not done(v) assert done(v) - done = RankStability(rtol=0.1, min_iterations=3) + done = RankCorrelation(rtol=0.1, burn_in=3) v = ValuationResult.from_random(size=5) assert not done(v) assert not done(v) assert not done(v) assert done(v) - done = RankStability(rtol=0.1, min_iterations=2) + done = RankCorrelation(rtol=0.1, burn_in=2) v = ValuationResult.from_random(size=5) assert not done(v) assert not done(v) From 8f25b53838026624c6dbe23fa3922f88059d449c Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 12 Apr 2024 16:20:10 +0200 Subject: [PATCH 39/42] Require explicit stopping criteria (impossible to provide good defaults) --- src/pydvl/value/semivalues.py | 18 +++++++----------- src/pydvl/value/shapley/common.py | 4 ++-- 2 files changed, 9 insertions(+), 13 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index e7bc53c7b..46cd1f16e 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -101,11 +101,7 @@ from deprecate import deprecated from tqdm import tqdm -from pydvl.parallel import ( - ParallelBackend, - _maybe_init_parallel_backend, - init_parallel_backend, -) +from pydvl.parallel import ParallelBackend, _maybe_init_parallel_backend from pydvl.parallel.config import ParallelConfig from pydvl.utils import Utility from pydvl.utils.types import IndexT, Seed @@ -117,7 +113,7 @@ SampleT, StochasticSampler, ) -from pydvl.value.stopping import MaxUpdates, RankCorrelation, StoppingCriterion +from pydvl.value.stopping import StoppingCriterion __all__ = [ "compute_banzhaf_semivalues", @@ -497,7 +493,7 @@ def beta_coefficient_w(n: int, k: int) -> float: def compute_shapley_semivalues( u: Utility, *, - done: StoppingCriterion = MaxUpdates(100), + done: StoppingCriterion, sampler_t: Type[StochasticSampler] = PermutationSampler, batch_size: int = 1, n_jobs: int = 1, @@ -567,7 +563,7 @@ def compute_shapley_semivalues( def compute_banzhaf_semivalues( u: Utility, *, - done: StoppingCriterion = MaxUpdates(100), + done: StoppingCriterion, sampler_t: Type[StochasticSampler] = PermutationSampler, batch_size: int = 1, n_jobs: int = 1, @@ -635,7 +631,7 @@ def compute_banzhaf_semivalues( def compute_msr_banzhaf_semivalues( u: Utility, *, - done: StoppingCriterion = RankCorrelation(0.01), + done: StoppingCriterion, sampler_t: Type[StochasticSampler] = MSRSampler, batch_size: int = 1, n_jobs: int = 1, @@ -704,7 +700,7 @@ def compute_beta_shapley_semivalues( *, alpha: float = 1, beta: float = 1, - done: StoppingCriterion = MaxUpdates(100), + done: StoppingCriterion, sampler_t: Type[StochasticSampler] = PermutationSampler, batch_size: int = 1, n_jobs: int = 1, @@ -782,7 +778,7 @@ class SemiValueMode(str, Enum): def compute_semivalues( u: Utility, *, - done: StoppingCriterion = MaxUpdates(100), + done: StoppingCriterion, mode: SemiValueMode = SemiValueMode.Shapley, sampler_t: Type[StochasticSampler] = PermutationSampler, batch_size: int = 1, diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index c407b3ba8..c9a767aa7 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -16,7 +16,7 @@ from pydvl.value.shapley.owen import OwenAlgorithm, owen_sampling_shapley from pydvl.value.shapley.truncated import NoTruncation from pydvl.value.shapley.types import ShapleyMode -from pydvl.value.stopping import MaxUpdates, StoppingCriterion +from pydvl.value.stopping import StoppingCriterion __all__ = ["compute_shapley_values"] @@ -24,7 +24,7 @@ def compute_shapley_values( u: Utility, *, - done: StoppingCriterion = MaxUpdates(100), + done: StoppingCriterion, mode: ShapleyMode = ShapleyMode.TruncatedMontecarlo, n_jobs: int = 1, seed: Optional[Seed] = None, From b3b2ec2690eaaa81b307aea64b418822c87c5915 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 12 Apr 2024 16:56:13 +0200 Subject: [PATCH 40/42] Missing exports --- src/pydvl/value/sampler.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 1aed0979a..3b915f5b7 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -75,14 +75,16 @@ __all__ = [ "AntitheticSampler", - "DeterministicUniformSampler", "DeterministicPermutationSampler", + "DeterministicUniformSampler", "MSRSampler", "PermutationSampler", "PowersetSampler", "RandomHierarchicalSampler", - "UniformSampler", + "SampleT", + "StochasticSampler", "StochasticSamplerMixin", + "UniformSampler", ] SampleT = Tuple[IndexT, NDArray[IndexT]] From f202f88a00e6ca2637402a8918cf9ee16834d352 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 12 Apr 2024 16:56:36 +0200 Subject: [PATCH 41/42] Further cleanup of the notebook (hiding cells, text changes) --- notebooks/msr_banzhaf_digits.ipynb | 246 +++++++++++++++++++++-------- 1 file changed, 180 insertions(+), 66 deletions(-) diff --git a/notebooks/msr_banzhaf_digits.ipynb b/notebooks/msr_banzhaf_digits.ipynb index 1a6239f3c..046d318e2 100644 --- a/notebooks/msr_banzhaf_digits.ipynb +++ b/notebooks/msr_banzhaf_digits.ipynb @@ -59,6 +59,8 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", + "from tqdm import tqdm\n", + "\n", "plt.ioff() # Prevent jupyter from automatically plotting\n", "plt.rcParams[\"figure.figsize\"] = (20, 6)\n", "plt.rcParams[\"font.size\"] = 12\n", @@ -148,7 +150,12 @@ { "cell_type": "code", "execution_count": 6, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input", + "invertible-output" + ] + }, "outputs": [ { "data": { @@ -204,8 +211,26 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from support.banzhaf import TorchCNNModel\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "model = TorchCNNModel(lr=0.001, epochs=40, batch_size=32, device=device)\n", + "model.fit(x=training_data[0], y=training_data[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", @@ -217,13 +242,6 @@ } ], "source": [ - "import torch\n", - "from support.banzhaf import TorchCNNModel\n", - "\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "model = TorchCNNModel(lr=0.001, epochs=40, batch_size=32, device=device)\n", - "model.fit(x=training_data[0], y=training_data[1])\n", - "\n", "print(f\"Train Accuracy: {model.score(x=training_data[0], y=training_data[1]):.3f}\")\n", "print(f\"Test Accuracy: {model.score(x=test_data[0], y=test_data[1]):.3f}\")" ] @@ -242,7 +260,11 @@ { "cell_type": "code", "execution_count": 9, - "metadata": {}, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -273,13 +295,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - ".The returned dataframe contains the mean and variance of the Monte Carlo estimates for the values:" + "The returned dataframe contains the mean and variance of the Monte Carlo estimates for the values:" ] }, { "cell_type": "code", "execution_count": 10, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { @@ -428,8 +454,7 @@ "slide_type": "" }, "tags": [ - "hide-input", - "invertible-output" + "hide-input" ] }, "outputs": [ @@ -468,8 +493,35 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, + "outputs": [], + "source": [ + "x_train_anomalous = training_data[0].copy()\n", + "y_train_anomalous = training_data[1].copy()\n", + "anomalous_indices = high_dvl.index.map(int).values[:10]\n", + "\n", + "# Set label of first 5 images to 0\n", + "y_train_anomalous[high_dvl.index.map(int).values[:5]] = 0\n", + "\n", + "# Add noise to images 6-10\n", + "indices = high_dvl.index.values[5:10].astype(int)\n", + "current_images = x_train_anomalous[indices]\n", + "noisy_images = current_images + 0.5 * np.random.randn(*current_images.shape)\n", + "noisy_images[noisy_images < 0] = 0.0\n", + "noisy_images[noisy_images > 1] = 1.0\n", + "x_train_anomalous[indices] = noisy_images" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "tags": [ + "hide-input", + "invertible-output" + ] + }, "outputs": [ { "data": { @@ -485,21 +537,6 @@ } ], "source": [ - "x_train_anomalous = training_data[0].copy()\n", - "y_train_anomalous = training_data[1].copy()\n", - "anomalous_indices = high_dvl.index.map(int).values[:10]\n", - "\n", - "# Set label of first 5 images to 0\n", - "y_train_anomalous[high_dvl.index.map(int).values[:5]] = 0\n", - "\n", - "# Add noise to images 6-10\n", - "indices = high_dvl.index.values[5:10].astype(int)\n", - "current_images = x_train_anomalous[indices]\n", - "noisy_images = current_images + 0.5 * np.random.randn(*current_images.shape)\n", - "noisy_images[noisy_images < 0] = 0.0\n", - "noisy_images[noisy_images > 1] = 1.0\n", - "x_train_anomalous[indices] = noisy_images\n", - "\n", "fig, axes = plt.subplots(2, 5, figsize=(9, 5))\n", "for i in range(5):\n", " axes[0, i].imshow(np.reshape(current_images[i], (8, 8)), cmap=\"gray\")\n", @@ -514,7 +551,11 @@ { "cell_type": "code", "execution_count": 14, - "metadata": {}, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -629,7 +670,11 @@ { "cell_type": "code", "execution_count": 16, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", @@ -700,7 +745,11 @@ { "cell_type": "code", "execution_count": 18, - "metadata": {}, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -733,7 +782,11 @@ { "cell_type": "code", "execution_count": 19, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { @@ -817,7 +870,12 @@ { "cell_type": "code", "execution_count": 20, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input", + "invertible-output" + ] + }, "outputs": [ { "data": { @@ -848,7 +906,12 @@ { "cell_type": "code", "execution_count": 21, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input", + "invertible-output" + ] + }, "outputs": [ { "data": { @@ -890,7 +953,11 @@ { "cell_type": "code", "execution_count": 22, - "metadata": {}, + "metadata": { + "tags": [ + "hide" + ] + }, "outputs": [], "source": [ "if is_CI:\n", @@ -950,7 +1017,11 @@ { "cell_type": "code", "execution_count": 25, - "metadata": {}, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -969,7 +1040,11 @@ { "cell_type": "code", "execution_count": 26, - "metadata": {}, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -989,7 +1064,11 @@ { "cell_type": "code", "execution_count": 27, - "metadata": {}, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -1007,7 +1086,11 @@ { "cell_type": "code", "execution_count": 28, - "metadata": {}, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -1025,7 +1108,11 @@ { "cell_type": "code", "execution_count": 29, - "metadata": {}, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -1043,7 +1130,12 @@ { "cell_type": "code", "execution_count": 30, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input", + "invertible-output" + ] + }, "outputs": [ { "data": { @@ -1120,7 +1212,11 @@ { "cell_type": "code", "execution_count": 31, - "metadata": {}, + "metadata": { + "tags": [ + "hide" + ] + }, "outputs": [], "source": [ "names = [\"Permutation\", \"MSR\", \"Uniform\", \"Antithetic\", \"RandomHierarchical\"]\n", @@ -1152,7 +1248,12 @@ { "cell_type": "code", "execution_count": 32, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input", + "invertible-output" + ] + }, "outputs": [ { "data": { @@ -1192,17 +1293,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This plot shows that the samplers lead to quite different Banzhaf semivalues, however, all of them have some points in common. \n", - "The MSR Sampler does not seem to be significantly worse than any others. \n", + "This plot shows that the samplers lead to quite different Banzhaf semivalues, however, all of them have some points in common. The MSR Sampler does not seem to be significantly worse than any others. \n", "\n", - "In an ideal setting without randomness, the overlap of points would be higher, however, the stochastic nature of the CNN model that we use together with the\n", - "fact that we use only 200 data points for training, might overshadow these results. " + "In an ideal setting without randomness, the overlap of points would be higher, however, the stochastic nature of the CNN model that we use together with the fact that we use only 200 data points for training, might overshadow these results. As a matter of fact we have the rather discouraging following result:" ] }, { "cell_type": "code", "execution_count": 33, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", @@ -1229,14 +1332,17 @@ "source": [ "### Consistency of the semivalues\n", "\n", - "In this part, we want to analyze how consistent the semivalues returned by the different samplers are. \n", - "To evaluate this, we will compute semivalues multiple times and check how many of the data points in the top and lowest 20% of valuation of the data overlap." + "Finally, we want to analyze how consistent the semivalues returned by the different samplers are. In order to do this, we compute semivalues multiple times and check how many of the data points in the top and lowest 20% of valuation of the data overlap." ] }, { "cell_type": "code", "execution_count": 34, - "metadata": {}, + "metadata": { + "tags": [ + "hide" + ] + }, "outputs": [], "source": [ "max_checks = [1000, 2000, 3000] if not is_CI else [1]\n", @@ -1248,7 +1354,11 @@ { "cell_type": "code", "execution_count": 35, - "metadata": {}, + "metadata": { + "tags": [ + "hide" + ] + }, "outputs": [ { "name": "stderr", @@ -1270,10 +1380,6 @@ } ], "source": [ - "# Run all experiments\n", - "from tqdm import tqdm\n", - "\n", - "\n", "results = [[[] for i in range(num_samplers)] for _ in max_checks]\n", "pbar = tqdm(total=len(max_checks) * num_retries * 5)\n", "for sampler_index, sampler in enumerate(\n", @@ -1303,7 +1409,11 @@ { "cell_type": "code", "execution_count": 36, - "metadata": {}, + "metadata": { + "tags": [ + "hide" + ] + }, "outputs": [], "source": [ "# Extract results from experiments\n", @@ -1342,7 +1452,12 @@ { "cell_type": "code", "execution_count": 37, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input", + "invertible-output" + ] + }, "outputs": [ { "data": { @@ -1379,12 +1494,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "**Conclusion:**\n", - "MSR sampling updates the semivalue estimates a lot more frequently than any other sampler available, which leads to a lot **faster convergence**. \n", - "Additionally, the sampler is more consistent with its value estimates than the other samplers, which might be caused by the higher number of value updates. \n", + "## Conclusion\n", + "\n", + "MSR sampling updates the semivalue estimates for every index in the sample, much more frequently than any other sampler available, which leads to much **faster convergence**. Additionally, the sampler is more consistent with its value estimates than the other samplers, which might be caused by the higher number of value updates. \n", "\n", - "In general, the recommendation is to try different samplers when computing semivalues and test, which one is best suited for your use case. The MSR sampler\n", - "seems like a more efficient sampler which may bring fast results and is well-suited for stochastic models." + "There is alas no general recommendation. It is best to try different samplers when computing semivalues and test which one is best suited for your use case. Nevertheless, the MSR sampler seems like a more efficient sampler which may bring fast results and is well-suited for stochastic models." ] } ], @@ -1405,7 +1519,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.2" + "version": "3.8.19" }, "vscode": { "interpreter": { From 426b8675d1c38ff01398290d59798bf776defe6b Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 12 Apr 2024 16:56:41 +0200 Subject: [PATCH 42/42] [skip ci] Update CHANGELOG.md --- CHANGELOG.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 67ed039a0..9fcced76e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,7 +6,8 @@ - New method: `NystroemSketchInfluence` [PR #504](https://github.com/aai-institute/pyDVL/pull/504) -- New method: `MSR Banzhaf Semivalues` +- New method `MSR Banzhaf` with accompanying notebook, and new stopping + criterion `RankCorrelation` [PR #520](https://github.com/aai-institute/pyDVL/pull/520) - New preconditioned block variant of conjugate gradient [PR #507](https://github.com/aai-institute/pyDVL/pull/507)